/* 

 * tclMacNotify.c --

 *

 *	This file contains Macintosh-specific procedures for the notifier,

 *	which is the lowest-level part of the Tcl event loop.  This file

 *	works together with ../generic/tclNotify.c.

 *

 *	The Mac notifier only polls for system and OS events, so it is process

 *	wide, rather than thread specific.  However, this means that the convert

 *	event proc will have to arbitrate which events go to which threads.

 *

 * Copyright (c) 1995-1996 Sun Microsystems, Inc.

 *

 * See the file "license.terms" for information on usage and redistribution

 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

 *

 * RCS: @(#) $Id: tclMacNotify.c,v 1.8.4.1 2003/03/21 03:24:08 dgp Exp $

 */

#include "tclInt.h"

#include "tclPort.h"

#include "tclMac.h"

#include "tclMacInt.h"

#include <signal.h>

#include <Events.h>

#include <LowMem.h>

#include <Processes.h>

#include <Timer.h>

#include <Threads.h>

/* 

 * This is necessary to work around a bug in Apple's Universal header files

 * for the CFM68K libraries.

 */

#ifdef __CFM68K__

#undef GetEventQueue

extern pascal QHdrPtr GetEventQueue(void)

 THREEWORDINLINE(0x2EBC, 0x0000, 0x014A);

#pragma import list GetEventQueue

#define GetEvQHdr() GetEventQueue()

#endif

/*

 * Need this for replacing Tcl_SetTimer and Tcl_WaitForEvent defined 

 * in THIS file with ones defined in the stub table.

 */

extern TclStubs tclStubs;

extern Tcl_NotifierProcs tclOriginalNotifier;

/*

 * The follwing static indicates whether this module has been initialized.

 */

static int initialized = 0;

/*

 * The following structure contains the state information for the

 * notifier module.

 */

static struct {

    int timerActive;		/* 1 if timer is running. */

    Tcl_Time timer;		/* Time when next timer event is expected. */

    int flags;			/* OR'ed set of flags defined below. */

    Point lastMousePosition;	/* Last known mouse location. */

    RgnHandle utilityRgn;	/* Region used as the mouse region for

				 * WaitNextEvent and the update region when

				 * checking for events. */   

    Tcl_MacConvertEventPtr eventProcPtr;

				/* This pointer holds the address of the

				 * function that will handle all incoming

				 * Macintosh events. */

} notifier;

/*

 * The following defines are used in the flags field of the notifier struct.

 */

#define NOTIFY_IDLE	(1<<1)	/* Tcl_ServiceIdle should be called. */

#define NOTIFY_TIMER	(1<<2)	/* Tcl_ServiceTimer should be called. */

/*

 * Prototypes for procedures that are referenced only in this file:

 */

static int		HandleMacEvents _ANSI_ARGS_((void));

static void		InitNotifier _ANSI_ARGS_((void));

static void		NotifierExitHandler _ANSI_ARGS_((

			    ClientData clientData));

/*

 *----------------------------------------------------------------------

 *

 * Tcl_InitNotifier --

 *

 *	Initializes the platform specific notifier state.  There is no thread

 *	specific platform notifier on the Mac, so this really doesn't do 

 *	anything.  However, we need to return the ThreadID, since the generic

 *	notifier hands this back to us in AlertThread.

 *

 * Results:

 *	Returns the threadID for this thread.  

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

ClientData

Tcl_InitNotifier()

{

#ifdef TCL_THREADS

    ThreadID curThread;

    if (TclMacHaveThreads()) {

        GetCurrentThread(&curThread);

        return (ClientData) curThread;

    } else {

        return NULL;

    }

#else

    return NULL;

#endif

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_FinalizeNotifier --

 *

 *	This function is called to cleanup the notifier state before

 *	a thread is terminated.  There is no platform thread specific

 *	notifier, so this does nothing.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

void

Tcl_FinalizeNotifier(clientData)

    ClientData clientData;	/* Pointer to notifier data. */

{

    /* Nothing to do on the Mac */

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_AlertNotifier --

 *

 *	Wake up the specified notifier from any thread. This routine

 *	is called by the platform independent notifier code whenever

 *	the Tcl_ThreadAlert routine is called.  This routine is

 *	guaranteed not to be called on a given notifier after

 *	Tcl_FinalizeNotifier is called for that notifier.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Calls YieldToThread from this thread.

 *

 *----------------------------------------------------------------------

 */

void

Tcl_AlertNotifier(clientData)

    ClientData clientData;	/* Pointer to thread data. */

{

#ifdef TCL_THREADS

    if (TclMacHaveThreads()) {

        YieldToThread((ThreadID) clientData);

    }

#endif

}

/*

 *----------------------------------------------------------------------

 *

 * InitNotifier --

 *

 *	Initializes the notifier structure.  Note - this function is never

 *	used.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Creates a new exit handler.

 *

 *----------------------------------------------------------------------

 */

static void

InitNotifier(void)

{

    initialized = 1;

    memset(&notifier, 0, sizeof(notifier));

    Tcl_CreateExitHandler(NotifierExitHandler, NULL);

}

/*

 *----------------------------------------------------------------------

 *

 * NotifierExitHandler --

 *

 *	This function is called to cleanup the notifier state before

 *	Tcl is unloaded.  This function is never used, since InitNotifier

 *	isn't either.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

static void

NotifierExitHandler(

    ClientData clientData)	/* Not used. */

{

    initialized = 0;

}

/*

 *----------------------------------------------------------------------

 *

 * HandleMacEvents --

 *

 *	This function checks for events from the Macintosh event queue.

 *

 * Results:

 *	Returns 1 if event found, 0 otherwise.

 *

 * Side effects:

 *	Pulls events off of the Mac event queue and then calls

 *	convertEventProc.

 *

 *----------------------------------------------------------------------

 */

static int

HandleMacEvents(void)

{

    EventRecord theEvent;

    int eventFound = 0, needsUpdate = 0;

    Point currentMouse;

    WindowRef windowRef;

    Rect mouseRect;

    /*

     * Check for mouse moved events.  These events aren't placed on the

     * system event queue unless we call WaitNextEvent.

     */

    GetGlobalMouseTcl(&currentMouse);

    if ((notifier.eventProcPtr != NULL) &&

	    !EqualPt(currentMouse, notifier.lastMousePosition)) {

	notifier.lastMousePosition = currentMouse;

	theEvent.what = nullEvent;

	if ((*notifier.eventProcPtr)(&theEvent) == true) {

	    eventFound = 1;

	}

    }

    /*

     * Check for update events.  Since update events aren't generated

     * until we call GetNextEvent, we may need to force a call to

     * GetNextEvent, even if the queue is empty.

     */

    for (windowRef = FrontWindow(); windowRef != NULL;

	    windowRef = GetNextWindow(windowRef)) {

	GetWindowUpdateRgn(windowRef, notifier.utilityRgn);

	if (!EmptyRgn(notifier.utilityRgn)) {

	    needsUpdate = 1;

	    break;

	}

    }

    /*

     * Process events from the OS event queue.

     */

    while (needsUpdate || (GetEvQHdr()->qHead != NULL)) {

	GetGlobalMouseTcl(&currentMouse);

	SetRect(&mouseRect, currentMouse.h, currentMouse.v,

		currentMouse.h + 1, currentMouse.v + 1);

	RectRgn(notifier.utilityRgn, &mouseRect);

	WaitNextEvent(everyEvent, &theEvent, 5, notifier.utilityRgn);

	needsUpdate = 0;

	if ((notifier.eventProcPtr != NULL)

		&& ((*notifier.eventProcPtr)(&theEvent) == true)) {

	    eventFound = 1;

	}

    }

    return eventFound;

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_SetTimer --

 *

 *	This procedure sets the current notifier timer value.  The

 *	notifier will ensure that Tcl_ServiceAll() is called after

 *	the specified interval, even if no events have occurred.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Replaces any previous timer.

 *

 *----------------------------------------------------------------------

 */

void

Tcl_SetTimer(

    Tcl_Time *timePtr)		/* New value for interval timer. */

{

    /*

     * Allow the notifier to be hooked.  This may not make sense

     * on the Mac, but mirrors the UNIX hook.

     */

    if (tclStubs.tcl_SetTimer != tclOriginalNotifier.setTimerProc) {

	tclStubs.tcl_SetTimer(timePtr);

	return;

    }

    if (!timePtr) {

	notifier.timerActive = 0;

    } else {

	/*

	 * Compute when the timer should fire.

	 */

	Tcl_GetTime(&notifier.timer);

	notifier.timer.sec += timePtr->sec;

	notifier.timer.usec += timePtr->usec;

	if (notifier.timer.usec >= 1000000) {

	    notifier.timer.usec -= 1000000;

	    notifier.timer.sec += 1;

	}

	notifier.timerActive = 1;

    }

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_ServiceModeHook --

 *

 *	This function is invoked whenever the service mode changes.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

void

Tcl_ServiceModeHook(mode)

    int mode;			/* Either TCL_SERVICE_ALL, or

				 * TCL_SERVICE_NONE. */

{

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_WaitForEvent --

 *

 *	This function is called by Tcl_DoOneEvent to wait for new

 *	events on the message queue.  If the block time is 0, then

 *	Tcl_WaitForEvent just polls the event queue without blocking.

 *

 * Results:

 *	Always returns 0.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

int

Tcl_WaitForEvent(

    Tcl_Time *timePtr)		/* Maximum block time. */

{

    int found;

    EventRecord macEvent;

    long sleepTime = 5;

    long ms;

    Point currentMouse;

    void * timerToken;

    Rect mouseRect;

    /*

     * Allow the notifier to be hooked.  This may not make

     * sense on the Mac, but mirrors the UNIX hook.

     */

    if (tclStubs.tcl_WaitForEvent != tclOriginalNotifier.waitForEventProc) {

	return tclStubs.tcl_WaitForEvent(timePtr);

    }

    /*

     * Compute the next timeout value.

     */

    if (!timePtr) {

	ms = INT_MAX;

    } else {

	ms = (timePtr->sec * 1000) + (timePtr->usec / 1000);

    }

    timerToken = TclMacStartTimer((long) ms);

    /*

     * Poll the Mac event sources.  This loop repeats until something

     * happens: a timeout, a socket event, mouse motion, or some other

     * window event.  Note that we don't call WaitNextEvent if another

     * event is found to avoid context switches.  This effectively gives

     * events coming in via WaitNextEvent a slightly lower priority.

     */

    found = 0;

    if (notifier.utilityRgn == NULL) {

	notifier.utilityRgn = NewRgn();

    }

    while (!found) {

	/*

	 * Check for generated and queued events.

	 */

	if (HandleMacEvents()) {

	    found = 1;

	}

	/*

	 * Check for time out.

	 */

	if (!found && TclMacTimerExpired(timerToken)) {

	    found = 1;

	}

	/*

	 * Check for window events.  We may receive a NULL event for

	 * various reasons. 1) the timer has expired, 2) a mouse moved

	 * event is occuring or 3) the os is giving us time for idle

	 * events.  Note that we aren't sharing the processor very

	 * well here.  We really ought to do a better job of calling

	 * WaitNextEvent for time slicing purposes.

	 */

	if (!found) {

	    /*

	     * Set up mouse region so we will wake if the mouse is moved.

	     * We do this by defining the smallest possible region around

	     * the current mouse position.

	     */

	    GetGlobalMouseTcl(&currentMouse);

	    SetRect(&mouseRect, currentMouse.h, currentMouse.v,

		    currentMouse.h + 1, currentMouse.v + 1);

	    RectRgn(notifier.utilityRgn, &mouseRect);

	    WaitNextEvent(everyEvent, &macEvent, sleepTime,

		    notifier.utilityRgn);

	    if (notifier.eventProcPtr != NULL) {

		if ((*notifier.eventProcPtr)(&macEvent) == true) {

		    found = 1;

		}

	    }

	}

    }

    TclMacRemoveTimer(timerToken);

    /*

     * Yield time to nay other thread at this point.  If we find that the

     * apps thrash too switching between threads, we can put a timer here,

     * and only yield when the timer fires.

     */

    if (TclMacHaveThreads()) {

        YieldToAnyThread();

    }

    return 0;

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_Sleep --

 *

 *	Delay execution for the specified number of milliseconds.  This

 *	is not a very good call to make.  It will block the system -

 *	you will not even be able to switch applications.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Time passes.

 *

 *----------------------------------------------------------------------

 */

void

Tcl_Sleep(

    int ms)			/* Number of milliseconds to sleep. */

{

    EventRecord dummy;

    void *timerToken;

    if (ms <= 0) {

	return;

    }

    timerToken = TclMacStartTimer((long) ms);

    while (1) {

	WaitNextEvent(0, &dummy, (ms / 16.66) + 1, NULL);

        if (TclMacHaveThreads()) {

	    YieldToAnyThread();

	}

	if (TclMacTimerExpired(timerToken)) {

	    break;

	}

    }

    TclMacRemoveTimer(timerToken);

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_MacSetEventProc --

 *

 *	This function sets the event handling procedure for the 

 *	application.  This function will be passed all incoming Mac

 *	events.  This function usually controls the console or some

 *	other entity like Tk.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Changes the event handling function.

 *

 *----------------------------------------------------------------------

 */

void

Tcl_MacSetEventProc(

    Tcl_MacConvertEventPtr procPtr)

{

    notifier.eventProcPtr = procPtr;

}