Tk Source Code

				 * being entered (EnterNotify or FocusIn). 0
				 * means don't generate enter events. */
    Tcl_QueuePosition position)	/* Position at which events are added to the
				 * system event queue. */
{
    TkWindow *winPtr;
    int upLevels, downLevels, i, j, focus;
#define NAME(w) (w ? Tk_PathName(w) : "NULL")
    
    fprintf(stderr, "TkInOutEvents: %s -> %s\n",
	    NAME(sourcePtr), NAME(destPtr));

    /*
     * There are four possible cases to deal with:
     *
     * 1. SourcePtr and destPtr are the same. There's nothing to do in this
     *    case.
     * 2. SourcePtr is an ancestor of destPtr in the same top-level window.

	} else {					\
	    eventPtr->xcrossing.detail = d;		\
	    TkChangeEventWindow(eventPtr, w);		\
	}						\
	Tk_QueueWindowEvent(eventPtr, position);	\
    }

#define DBGEV(w, t, d) fprintf(stderr, "    Queueing %s %s for %s\n", t, d, NAME(w))

    if (downLevels == 0) {
	/*
	 * SourcePtr is an inferior of destPtr.
	 */

	if (leaveType != 0) {
	    DBGEV(sourcePtr, "<Leave>", "NotifyAncestor");
	    QUEUE(sourcePtr, leaveType, NotifyAncestor);
	    for (winPtr = sourcePtr->parentPtr, i = upLevels-1; i > 0;
		    winPtr = winPtr->parentPtr, i--) {
		DBGEV(winPtr, "<Leave>", "NotifyVirtual");
		QUEUE(winPtr, leaveType, NotifyVirtual);
	    }
	}
	if ((enterType != 0) && (destPtr != NULL)) {
	    DBGEV(destPtr, "<Enter>", "NotifyVirtual");
	    QUEUE(destPtr, enterType, NotifyInferior);
	}
    } else if (upLevels == 0) {
	/*
	 * DestPtr is an inferior of sourcePtr.
	 */

	if ((leaveType != 0) && (sourcePtr != NULL)) {
	    DBGEV(sourcePtr, "<Leave>", "NotifyInferior");
	    QUEUE(sourcePtr, leaveType, NotifyInferior);
	}
	if (enterType != 0) {
	    for (i = downLevels-1; i > 0; i--) {
		for (winPtr = destPtr->parentPtr, j = 1; j < i;
			winPtr = winPtr->parentPtr, j++) {
		    /* empty */
		}
		DBGEV(winPtr, "<Enter>", "NotifyVirtual");
		QUEUE(winPtr, enterType, NotifyVirtual);
	    }
	    if (destPtr != NULL) {
		DBGEV(winPtr, "<Enter>", "NotifyVirtual");
		QUEUE(destPtr, enterType, NotifyAncestor);
	    }
	}
    } else {
	/*
	 * Non-linear: neither window is an inferior of the other.
	 */

	if (leaveType != 0) {
	    DBGEV(sourcePtr, "<Leave>", "NotifyNonlinear");
	    QUEUE(sourcePtr, leaveType, NotifyNonlinear);
	    for (winPtr = sourcePtr->parentPtr, i = upLevels-1; i > 0;
		    winPtr = winPtr->parentPtr, i--) {
	    DBGEV(winPtr, "<Leave>", "NotifyNonlinearVirtual");
	    QUEUE(winPtr, leaveType, NotifyNonlinearVirtual);
	    }
	}
	if (enterType != 0) {
	    for (i = downLevels-1; i > 0; i--) {
		for (winPtr = destPtr->parentPtr, j = 1; j < i;
			winPtr = winPtr->parentPtr, j++) {
		}
		DBGEV(winPtr, "<Enter>", "NotifyNonlinearVirtual");
		QUEUE(winPtr, enterType, NotifyNonlinearVirtual);
	    }
	    if (destPtr != NULL) {
		DBGEV(destPtr, "<Enter>", "NotifyNonlinear");
		QUEUE(destPtr, enterType, NotifyNonlinear);
	    }
	}
    }
    fflush(stderr);
}


    TkWindow *winPtr = (TkWindow *)tkwin;
    TkWindow *targetWinPtr;
    XPoint pos;
    XEvent event;
    unsigned changes = (state ^ tsdPtr->lastState) & ALL_BUTTONS;
    int type, b;
    unsigned mask;
    fprintf(stderr, "TkUpdatePointer: %s -> %s\n",
	    tsdPtr->lastWinPtr ? Tk_PathName(tsdPtr->lastWinPtr) : "NULL",
	    tkwin ? Tk_PathName(tkwin) : "NULL");
    fflush(stderr);
    pos.x = x;
    pos.y = y;

    /*
     * Use the current keyboard state, but the old mouse button state since we
     * haven't generated the button events yet.
     */

void
TkPointerDeadWindow(
    TkWindow *winPtr)
{
    ThreadSpecificData *tsdPtr =
	    Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
    fprintf(stderr, "TkPointerDeadWindow: %s\n", winPtr ? Tk_PathName(winPtr) : "NULL");
    if (winPtr == tsdPtr->lastWinPtr) {
	//This fails on Windows because the windows version of TkWnDeadWindow
	//does not (yet)  call TkUpdatePointer when a dead toplevel contains the
	//pointer.
	tsdPtr->lastWinPtr = TkGetContainer(winPtr);
    }
    if (winPtr == tsdPtr->grabWinPtr) {
	tsdPtr->grabWinPtr = NULL;
    }
    if (winPtr == tsdPtr->restrictWinPtr) {
	tsdPtr->restrictWinPtr = NULL;

 */

static void SendEnterLeaveForDestroy(
    Tk_Window tkwin)
{
#if defined(MAC_OSX_TK) || defined(_WIN32)
    int x, y;
    unsigned int state = TkWinGetModifierState();
    Tk_Window pointerWin;
    TkWindow *containerPtr;


    TkGetPointerCoords(NULL, &x, &y);
    pointerWin = Tk_CoordsToWindow(x, y, tkwin);
    if (pointerWin == tkwin) {
	if (!Tk_IsTopLevel(tkwin)) {
	    containerPtr = TkGetContainer((TkWindow *)pointerWin);
	    Tk_UpdatePointer((Tk_Window) containerPtr, x, y, state);
	}
	else if (pointerWin) {

test event-9.13 {pointer window is a toplevel, toplevel destination} -setup {
    setup_win_mousepointer .one
    toplevel .two
    wm geometry .two 300x300+150+150
    wm withdraw .two
    wm deiconify .two
    waitForWindowEvent .two <Enter>
    bind all <Leave> {append result "<Leave> %d %W|" ; puts stderr "=leave=" }
    bind all <Enter> {append result "<Enter> %d %W|" ; puts stderr "-enter=" }
    set result |
} -body {
    destroy .two
    waitForWindowEvent .one <Enter>
    # destroying .one here instead of in cleanup makes the test pass
    destroy .one
    set result