static
void *exec(void *arg)
{
ws_state_list *p = (ws_state_list *) arg;
EventRecord event;
create_window(p);
init_norm_xform();
init_colors();
create_patterns();
p->run = 1;
while (p->run)
{
pthread_mutex_lock(&p->mutex);
while (EventAvail(everyEvent, &event))
{
GetNextEvent(everyEvent, &event);
if (event.what == kHighLevelEvent)
AEProcessAppleEvent(&event);
}
pthread_mutex_unlock(&p->mutex);
usleep(10000);
}
DisposeWindow(p->win);
pthread_exit(0);
return 0;
}
OSStatus GHOST_SystemCarbon::sEventHandlerProc(EventHandlerCallRef handler, EventRef event, void *userData)
{
GHOST_SystemCarbon *sys = (GHOST_SystemCarbon *) userData;
OSStatus err = eventNotHandledErr;
GHOST_IWindow *window;
#ifdef WITH_INPUT_NDOF
GHOST_TEventNDOFData data;
#endif
UInt32 kind;
switch (::GetEventClass(event))
{
case kEventClassAppleEvent:
EventRecord eventrec;
if (ConvertEventRefToEventRecord(event, &eventrec)) {
err = AEProcessAppleEvent(&eventrec);
}
break;
case kEventClassMouse:
err = sys->handleMouseEvent(event);
break;
case kEventClassWindow:
err = sys->handleWindowEvent(event);
break;
case kEventClassKeyboard:
err = sys->handleKeyEvent(event);
break;
case kEventClassBlender:
#ifdef WITH_INPUT_NDOF
window = sys->m_windowManager->getActiveWindow();
sys->m_ndofManager->GHOST_NDOFGetDatas(data);
kind = ::GetEventKind(event);
switch (kind)
{
case 1:
sys->m_eventManager->pushEvent(new GHOST_EventNDOF(sys->getMilliSeconds(), GHOST_kEventNDOFMotion, window, data));
// printf("motion\n");
break;
case 2:
sys->m_eventManager->pushEvent(new GHOST_EventNDOF(sys->getMilliSeconds(), GHOST_kEventNDOFButton, window, data));
// printf("button\n");
break;
}
#endif
err = noErr;
break;
default:
;
break;
}
return err;
}
pascal OSStatus wxMacAppEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
{
EventRef formerEvent = (EventRef) wxTheApp->MacGetCurrentEvent() ;
EventHandlerCallRef formerEventHandlerCallRef = (EventHandlerCallRef) wxTheApp->MacGetCurrentEventHandlerCallRef() ;
wxTheApp->MacSetCurrentEvent( event , handler ) ;
OSStatus result = eventNotHandledErr ;
switch ( GetEventClass( event ) )
{
case kEventClassCommand :
result = wxMacAppCommandEventHandler( handler , event , data ) ;
break ;
case kEventClassApplication :
result = wxMacAppApplicationEventHandler( handler , event , data ) ;
break ;
case kEventClassMenu :
result = wxMacAppMenuEventHandler( handler , event , data ) ;
break ;
case kEventClassMouse :
{
wxMacCarbonEvent cEvent( event ) ;
WindowRef window ;
Point screenMouseLocation = cEvent.GetParameter<Point>(kEventParamMouseLocation) ;
::FindWindow(screenMouseLocation, &window);
// only send this event in case it had not already been sent to a tlw, as we get
// double events otherwise (in case event.skip) was called
if ( window == NULL )
result = wxMacTopLevelMouseEventHandler( handler , event , NULL ) ;
}
break ;
case kEventClassAppleEvent :
{
EventRecord rec ;
wxMacConvertEventToRecord( event , &rec ) ;
result = AEProcessAppleEvent( &rec ) ;
}
break ;
default :
break ;
}
wxTheApp->MacSetCurrentEvent( formerEvent, formerEventHandlerCallRef ) ;
return result ;
}
int
HandleHighLevelEvents(
EventRecord *eventPtr)
{
int eventFound = false;
if (eventPtr->what == kHighLevelEvent) {
AEProcessAppleEvent(eventPtr);
eventFound = true;
} else if (eventPtr->what == nullEvent) {
eventFound = true;
}
return eventFound;
}
static PyObject *AE_AEProcessAppleEvent(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
OSErr _err;
EventRecord theEventRecord;
#ifndef AEProcessAppleEvent
PyMac_PRECHECK(AEProcessAppleEvent);
#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetEventRecord, &theEventRecord))
return NULL;
_err = AEProcessAppleEvent(&theEventRecord);
if (_err != noErr) return PyMac_Error(_err);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
void doEvents(EventRecord *eventStrucPtr)
{
WindowRef windowRef;
if (eventStrucPtr->what == mouseDown &&
FindWindow(eventStrucPtr->where,&windowRef) == inMenuBar)
SelectWindow(SIOUXTextWindow->window);
SIOUXSettings.standalone = true;
if (SIOUXHandleOneEvent(eventStrucPtr))
{
if (SIOUXQuitting)
gDone = true;
SIOUXSettings.standalone = false;
return;
}
SIOUXSettings.standalone = false;
switch(eventStrucPtr->what)
{
case kHighLevelEvent:
AEProcessAppleEvent(eventStrucPtr);
break;
case mouseDown:
doMouseDown(eventStrucPtr);
break;
case keyDown:
case autoKey:
break;
case updateEvt:
doUpdate(eventStrucPtr);
break;
case activateEvt:
DrawGrowIcon(windowRef);
break;
case osEvt:
doOSEvent(eventStrucPtr);
break;
}
}
static void apple_main_event_loop()
{
Boolean gotEvent;
EventRecord event;
UInt32 timeout = 1*60; // number of ticks (1/60th of a second)
VS("LOADER: Entering AppleEvent main loop.\n");
while (!gQuit)
{
gotEvent = WaitNextEvent(highLevelEventMask, &event, timeout, NULL);
if (gotEvent)
{
VS("LOADER: Processing an AppleEvent.\n");
AEProcessAppleEvent(&event);
}
gQuit = true;
}
}
int _handle_user_event( unsigned long ticks)
{
EventRecord event;
if( WaitNextEvent(everyEvent, &event, ticks, nil)){
long menuResult = 0;
short menuID, menuItem;
WindowPtr window;
Str255 daName;
switch ( event.what ) {
case mouseDown:
if( FindWindow(event.where, &window) == inMenuBar)
menuResult = MenuSelect(event.where);
break;
case keyDown:
if( event.modifiers & cmdKey )
menuResult = MenuKey((short)event.message & charCodeMask);
break;
case kHighLevelEvent:
AEProcessAppleEvent(&event);
break;
}
menuID = HiWord(menuResult);
menuItem = LoWord(menuResult);
switch ( menuID ) {
case mFile:
MLDone = MLAbort = 1;
break;
case mApple:
switch ( menuItem ) {
case iAbout:
do_about_box();
break;
default:
GetMenuItemText(GetMenuHandle(mApple), menuItem, daName);
break;
}
HiliteMenu(0);
}
}
return MLDone;
}
static void handleevent (EventRecord *ev) {
switch ((*ev).what) {
case keyDown: case autoKey:
handlekeystroke (ev);
break;
case mouseDown:
handlemouse (ev);
break;
case updateEvt:
handleupdate (ev);
break;
case osEvt:
handlejuggle (ev);
break;
case kHighLevelEvent:
AEProcessAppleEvent (ev);
break;
case nullEvent: /*See Step #2*/
if (flcurrentlyactive)
CheckSharedMenus (firstsharedmenu);
break;
} /*switch*/
} /*handleevent*/
static void mac_event(EventRecord *event) {
short part;
WindowPtr window;
switch (event->what) {
case mouseDown:
part = FindWindow(event->where, &window);
switch (part) {
case inMenuBar:
mac_adjustmenus();
mac_menucommand(MenuSelect(event->where));
break;
#if !TARGET_API_MAC_CARBON
case inSysWindow:
SystemClick(event, window);
break;
#endif
case inContent:
if (window != FrontWindow())
/* XXX: check for movable modal dboxes? */
SelectWindow(window);
else
mac_contentclick(window, event);
break;
case inGoAway:
if (TrackGoAway(window, event->where))
mac_closewindow(window);
break;
case inDrag:
/* XXX: moveable modal check? */
#if TARGET_API_MAC_CARBON
{
BitMap screenBits;
GetQDGlobalsScreenBits(&screenBits);
DragWindow(window, event->where, &screenBits.bounds);
}
#else
DragWindow(window, event->where, &qd.screenBits.bounds);
#endif
break;
case inGrow:
mac_growwindow(window, event);
break;
case inZoomIn:
case inZoomOut:
if (TrackBox(window, event->where, part))
mac_zoomwindow(window, part);
break;
}
break;
case keyDown:
case autoKey:
mac_keypress(event);
break;
case activateEvt:
mac_activatewindow((WindowPtr)event->message, event);
break;
case updateEvt:
mac_updatewindow((WindowPtr)event->message);
break;
#if !TARGET_API_MAC_CARBON
case diskEvt:
if (HiWord(event->message) != noErr) {
Point pt;
SetPt(&pt, 120, 120);
DIBadMount(pt, event->message);
}
break;
#endif
case osEvt:
switch ((event->message & osEvtMessageMask) >> 24) {
case suspendResumeMessage:
mac_suspendresume(event);
break;
}
break;
case kHighLevelEvent:
AEProcessAppleEvent(event); /* errors? */
break;
}
}
void DoEvent(EventRecord *event)
{
short part;
Boolean hit;
char key;
Rect tempRect;
WindowRef whichWindow;
switch (event->what)
{
case mouseDown:
part = FindWindow(event->where, &whichWindow);
switch (part)
{
case inMenuBar: /* process a moused menu command */
DoMenuCommand(MenuSelect(event->where));
break;
case inSysWindow:
break;
case inContent:
if (whichWindow != FrontWindow())
SelectWindow(whichWindow);
break;
case inDrag: /* pass screenBits.bounds */
GetRegionBounds(GetGrayRgn(), &tempRect);
DragWindow(whichWindow, event->where, &tempRect);
break;
case inGrow:
break;
case inGoAway:
DisposeWindow(whichWindow);
ExitToShell();
break;
case inZoomIn:
case inZoomOut:
hit = TrackBox(whichWindow, event->where, part);
if (hit)
{
SetPort(GetWindowPort(whichWindow)); // window must be current port
EraseRect(GetWindowPortBounds(whichWindow, &tempRect)); // inval/erase because of ZoomWindow bug
ZoomWindow(whichWindow, part, true);
InvalWindowRect(whichWindow, GetWindowPortBounds(whichWindow, &tempRect));
}
break;
}
break;
case keyDown:
case autoKey:
key = event->message & charCodeMask;
if (event->modifiers & cmdKey)
if (event->what == keyDown)
DoMenuCommand(MenuKey(key));
case activateEvt: /* if you needed to do something special */
break;
case updateEvt:
DrawWindow((WindowRef) event->message);
break;
case kHighLevelEvent:
AEProcessAppleEvent( event );
break;
case diskEvt:
break;
}
}
int
TkMacOSXDoHLEvent(
EventRecord *theEvent)
{
return AEProcessAppleEvent(theEvent);
}
static void process_event(
EventRecord *event)
{
WindowPtr window;
short part_code;
Rect size_rect;
long new_size;
GrafPtr old_port;
switch(event->what)
{
case kHighLevelEvent:
AEProcessAppleEvent(event);
break;
case mouseDown:
/* Did we hit one of the floaters? */
part_code= FindWindow(event->where, &window);
switch (part_code)
{
case inSysWindow:
break;
case inMenuBar:
do_menu_command(MenuSelect(event->where));
break;
case inContent:
if(window != FrontWindow())
SelectWindow(window);
click_in_log_window(window,event->where,(event->modifiers & shiftKey) != 0);
break;
case inDrag:
#ifdef OP_PLATFORM_MAC_CARBON_FLAG
{
Rect tempRect;
GetRegionBounds(GetGrayRgn(), &tempRect);
DragWindow(window, event->where, &tempRect);
}
#else
DragWindow(window, event->where, &qd.screenBits.bounds);
#endif
break;
case inGrow:
#ifdef OP_PLATFORM_MAC_CARBON_FLAG
GetRegionBounds(GetGrayRgn(), &size_rect);
#else
size_rect = qd.screenBits.bounds;
#endif
InsetRect(&size_rect, 4, 4);
new_size= GrowWindow(window, event->where, &size_rect);
if(new_size)
{
/* Resize the window */
SizeWindow(window, LoWord(new_size), HiWord(new_size), true);
}
break;
case inGoAway:
if(TrackGoAway(window, event->where))
{
/* Close the window... */
handle_close(window);
}
break;
case inZoomIn:
case inZoomOut:
if(TrackBox(window, event->where, part_code))
{
GetPort(&old_port);
SetPortWindowPort(window);
#ifdef OP_PLATFORM_MAC_CARBON_FLAG
{
Rect windowBounds;
GetWindowPortBounds(window, &windowBounds);
EraseRect(&windowBounds);
}
#else
EraseRect(&window->portRect);
#endif
ZoomWindow(window, part_code, true);
SetPort(old_port);
}
break;
}
break;
case keyDown:
case autoKey:
if(!process_key(event, event->message&charCodeMask))
{
/* Not handled by anyone.. */
SysBeep(-1);
}
break;
case updateEvt:
/* Update the window.. */
update_window((WindowPtr)event->message);
break;
case activateEvt:
/* Activate event->message, event->modifiers&activeFlag.. */
break;
case osEvt:
switch ((event->message>>24) & 0xff)
{
case suspendResumeMessage:
if (event->message&resumeFlag)
{
/* resume */
#ifdef OP_PLATFORM_MAC_CARBON_FLAG
{
Cursor arrowCursor;
SetCursor(GetQDGlobalsArrow(&arrowCursor));
}
#else
SetCursor(&qd.arrow);
#endif
}
else
{
/* suspend */
}
break;
case mouseMovedMessage:
break;
}
break;
}
return;
}
// --------------------------------------------------------------------------------------
static void handleEvents(EventRecord *event)
{
WindowRef window;
Boolean activate;
WindowPartCode partCode;
OSErr error;
Rect tempRect, newSize;
long menuChoice;
MenuCommand commandID;
RgnHandle grayRegion;
switch (event->what) // handle events according to the priority
{ // determined by the system
case activateEvt:
window = (WindowRef)event->message;
activate = (event->modifiers & activeFlag) != 0;
HandleActivate(window, activate);
break;
case mouseDown:
partCode = FindWindow(event->where, &window);
switch(partCode)
{
case inMenuBar:
menuChoice = MenuSelect(event->where);
error = GetMenuItemCommandID(GetMenuRef(HiWord(menuChoice)),
LoWord(menuChoice), &commandID);
if (error == noErr)
{
if (commandID == 0) // if the menu item clicked on does not have
commandID = (MenuCommand)menuChoice; // a command ID
HandleMenuChoice(commandID);
}
break;
case inSysWindow:
if (window != NULL)
SystemClick(event, window);
break;
case inContent: // the following window part codes will only be returned
if (window != FrontWindow()) // for the preferences window
SelectWindow(window);
else
HandleContentClick(window, event->where, event->modifiers);
break;
case inDrag:
grayRegion = GetGrayRgn();
DragWindow(window, event->where, &((*grayRegion)->rgnBBox));
break;
case inGrow:
SetRect(&tempRect, kPrefsWindowPlatinumWidth, kPrefsWindowPlatinumHeight,
SHRT_MAX, SHRT_MAX);
ResizeWindow(window, event->where, &tempRect, &newSize);
AdjustControls(window);
break;
case inGoAway:
ClosePrefsWindow(window);
break;
}
break;
case keyDown:
case autoKey: // a separate auto key handler would go after disk events
if ((event->modifiers & cmdKey) != 0)
{
UInt32 keyMenuChoice;
keyMenuChoice = MenuEvent(event);
error = GetMenuItemCommandID(GetMenuRef(HiWord(keyMenuChoice)),
LoWord(keyMenuChoice), &commandID);
if (error == noErr)
{
if (commandID == 0) // if the menu item chosen does not have a
commandID = (MenuCommand)keyMenuChoice; // command ID
HandleMenuChoice(commandID); // (but they all should)
}
}
else
{
window = FrontNonFloatingWindow();
if (window != NULL)
{
char keyCode = (event->message & keyCodeMask) >> 8;
HandleKeyDown(keyCode, window);
}
}
break;
case diskEvt:
if (HiWord(event->message) != noErr)
{
Point where;
SetPt(&where, 70, 50);
ShowCursor();
DIBadMount(where, event->message);
}
break;
case updateEvt:
window = (WindowRef)event->message;
SetPortWindowPort(window);
BeginUpdate(window);
HandleDrawContent(window);
EndUpdate(window);
break;
case kHighLevelEvent: // an OS Event handler would go before high level events
AEProcessAppleEvent(event);
break;
}
int
TkMacOSXDoHLEvent(
void *theEvent)
{
return AEProcessAppleEvent(theEvent);
}
void wxDrop_GetArgs(int *argc, char ***argv, int *in_terminal)
{
*in_terminal = 1;
MZ_REGISTER_STATIC(scheme_mac_argv);
Install();
while (!scheme_mac_ready) {
EventRecord event;
WaitNextEvent(highLevelEventMask, &event, 0x7FFFFFFF, 0L);
if (event.what == kHighLevelEvent) {
AEProcessAppleEvent(&event);
}
}
#ifdef OS_X
{
int from_finder;
from_finder = (((*argc) > 1) && (strncmp((*argv)[1],"-psn_",5) == 0));
if (from_finder) {
/* Finder started app, or someone wants us to think so; set
*in_terminal to 0 and combine AE-based command-line with given
command line */
int i, new_argc;
char **new_argv;
*in_terminal = 0;
new_argc = (scheme_mac_argc - 1) + ((*argc) - 2) + 1;
new_argv = (char **)malloc(new_argc * sizeof(char *));
new_argv[0] = (*argv)[0];
for (i = 2; i < (*argc); i++) {
new_argv[i - 1] = (*argv)[i];
}
for (; i < new_argc + 1; i++) {
new_argv[i - 1] = scheme_mac_argv[i - (*argc) + 1];
}
scheme_mac_argc = new_argc;
scheme_mac_argv = new_argv;
} else {
/* command-line start; no AE arguments */
scheme_mac_argc = *argc;
scheme_mac_argv = *argv;
}
GetStarterInfo();
/* Open the PLT_MrEd framework resources: */
{
CFBundleRef fwBundle;
fwBundle = CFBundleGetBundleWithIdentifier(CFSTR("org.plt-scheme.PLT_MrEd"));
if (fwBundle) {
SInt16 refNum;
SInt16 lRefNum;
CFBundleOpenBundleResourceFiles(fwBundle, &refNum, &lRefNum);
}
}
}
#endif
*argc = scheme_mac_argc;
*argv = scheme_mac_argv;
}
