Tk Source Code

 * bits.
 */

#define META_MASK	(AnyModifier<<1)
#define ALT_MASK	(AnyModifier<<2)
#define EXTENDED_MASK	(AnyModifier<<3)

/*
 * The following special modifiers are passed to Tk_UpdatePointer to specify
 * respectively that the cursor should not be changed, and to say to update
 * the current position but not to generate button events.
 */

#define NOCURSOR_MASK	(AnyModifier<<4)
#define NOBUTTONEVENTS_MASK	(AnyModifier<<5)

/*
 * Object types not declared in tkObj.c need to be mentioned here so they can
 * be properly registered with Tcl:
 */

MODULE_SCOPE const Tcl_ObjType tkBorderObjType;
MODULE_SCOPE const Tcl_ObjType tkBitmapObjType;

    Tk_Window tkwin,		/* Window to which pointer event is reported.
				 * May be NULL. */
    int x, int y,		/* Pointer location in root coords. */
    int state)			/* Modifier state mask. */
{
    ThreadSpecificData *tsdPtr =
	    Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
    TkWindow *winPtr = (TkWindow *) tkwin;
    TkWindow *targetWinPtr;
    XPoint pos;
    XEvent event;
    int no_cursor = (state & NOCURSOR_MASK);
    int no_button_events = (state & NOBUTTONEVENTS_MASK);
    int changes, type, b, mask;

    if (state & ALL_BUTTONS) {
	tsdPtr->lastState &= ~NOCURSOR_MASK;
    }
    state &= ~NOCURSOR_MASK & ~NOBUTTONEVENTS_MASK;
    if (no_cursor) {
	tsdPtr->lastState &= ~ALL_BUTTONS;
	tsdPtr->lastState |= (state & ALL_BUTTONS) | NOCURSOR_MASK;
	return;
    } else if (tsdPtr->lastState & NOCURSOR_MASK) {
	tsdPtr->lastState &= ~(NOCURSOR_MASK | ALL_BUTTONS);
	tsdPtr->lastState |= state & ALL_BUTTONS;
	return;
    }
    changes = (state ^ tsdPtr->lastState) & ALL_BUTTONS;
    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.
     */

    tsdPtr->lastState = (state & ~ALL_BUTTONS) | (tsdPtr->lastState
	    & ALL_BUTTONS);

    if (no_button_events) {
	return;
    }

    /*
     * Generate Enter/Leave events. If the pointer has crossed window
     * boundaries, update the current mouse position so we don't generate
     * redundant motion events.
     */

 *----------------------------------------------------------------------
 */

void
TkpSetCursor(
    TkpCursor cursor)
{
    static HCURSOR hcursor_idc_help = NULL;
				/* the hcursor_idc_help test is necessary for
				 * the CONTEXT HELP to work by using [wm
				 * attributes $window -contexthelp]. */
    HCURSOR hcursor;
    TkWinCursor *winCursor = (TkWinCursor *) cursor;

    if (winCursor == NULL || winCursor->winCursor == NULL) {
	hcursor = LoadCursor(NULL, TK_DEFAULT_CURSOR);
    } else {
	hcursor = winCursor->winCursor;
    }

    if (hcursor_idc_help == NULL) {
	hcursor_idc_help = LoadCursor(NULL, IDC_HELP);
    }
    if (GetCursor() == hcursor_idc_help) {
	return;
    }
    if (hcursor != NULL) {
	SetCursor(hcursor);
    }
}

/*
 * Local Variables:

 *	windows control (eg a button) then it will be activated by accident.
 *
 * 	This problem does not occur in dialog boxes, because windows must do
 * 	some special processing to solve the problem. (separate message
 * 	processing functions are used to cope with keyboard navigation of
 * 	controls.)
 *














 * Results:
 *	None.
 *
 * Side effects:
 *	Consumes unwanted mouse related messages.
 *
 *-------------------------------------------------------------------------
 */

static void
EatSpuriousMessageBugFix(void)
{


    int state = TkWinGetModifierState();



    Tk_UpdatePointer(NULL, 0, 0, state | NOBUTTONEVENTS_MASK);
}

/*
 *-------------------------------------------------------------------------
 *
 * TkWinDialogDebug --
 *

#ifndef WS_EX_TOOLWINDOW
#define WS_EX_TOOLWINDOW	0x00000080L
#endif
#ifndef SPI_SETKEYBOARDCUES
#define SPI_SETKEYBOARDCUES 0x100B
#endif

#ifndef CS_DROPSHADOW
#define CS_DROPSHADOW		0x00020000
#endif

/*
 * The TkWinDCState is used to save the state of a device context so that it
 * can be restored later.
 */

typedef struct TkWinDCState {
    HPALETTE palette;

#define TkWinGetPalette(colormap) (((TkWinColormap *) colormap)->palette)

/*
 * The following macros define the class names for Tk Window types.
 */

#define TK_WIN_TOPLEVEL_CLASS_NAME TEXT("TkTopLevel")
#define TK_WIN_TOPLEVEL_SHADOW_CLASS_NAME TEXT("TkTopLevelShadow")
#define TK_WIN_CHILD_CLASS_NAME TEXT("TkChild")

/*
 * The following variable is a translation table between X gc functions and
 * Win32 raster and BitBlt op modes.
 */

#define WM_MOVE_PENDING			(1<<7)
#define WM_COLORMAPS_EXPLICIT		(1<<8)
#define WM_ADDED_TOPLEVEL_COLORMAP	(1<<9)
#define WM_WIDTH_NOT_RESIZABLE		(1<<10)
#define WM_HEIGHT_NOT_RESIZABLE		(1<<11)
#define WM_WITHDRAWN			(1<<12)
#define WM_FULLSCREEN			(1<<13)
#define WM_DROPSHADOW			(1<<14)

/*
 * Window styles for various types of toplevel windows.
 */

#define WM_OVERRIDE_STYLE (WS_CLIPCHILDREN|WS_CLIPSIBLINGS|CS_DBLCLKS)
#define EX_OVERRIDE_STYLE (WS_EX_TOOLWINDOW)

		tsdPtr->iconPtr = titlebaricon;
	    }
	    class.hCursor = LoadCursor(NULL, IDC_ARROW);

	    if (!RegisterClass(&class)) {
		Tcl_Panic("Unable to register TkTopLevel class");
	    }

	    class.style = CS_HREDRAW | CS_VREDRAW | CS_DROPSHADOW;
	    class.lpszClassName = TK_WIN_TOPLEVEL_SHADOW_CLASS_NAME;

	    if (!RegisterClass(&class)) {
		Tcl_Panic("Unable to register TkTopLevelShadow class");
	    }
	}
	Tcl_MutexUnlock(&winWmMutex);
    }
    return TCL_OK;
}

/*

    if (!tsdPtr->initialized) {
	return;
    }
    tsdPtr->initialized = 0;

    UnregisterClass(TK_WIN_TOPLEVEL_CLASS_NAME, hInstance);
    Unregisterclass(TK_WIN_TOPLEVEL_SHADOW_CLASS_NAME, hInstance);
}

/*
 *--------------------------------------------------------------
 *
 * TkWmNewWindow --
 *

	 */

	tsdPtr->createWindow = winPtr;
	Tcl_WinUtfToTChar(((wmPtr->title != NULL) ?
		wmPtr->title : winPtr->nameUid), -1, &titleString);

	wmPtr->wrapper = CreateWindowEx(wmPtr->exStyle,
		(wmPtr->flags & WM_DROPSHADOW
			? TK_WIN_TOPLEVEL_SHADOW_CLASS_NAME
			: TK_WIN_TOPLEVEL_CLASS_NAME),
		(LPCTSTR) Tcl_DStringValue(&titleString),
		wmPtr->style, x, y, width, height,
		parentHWND, NULL, Tk_GetHINSTANCE(), NULL);
	Tcl_DStringFree(&titleString);
	SetWindowLongPtr(wmPtr->wrapper, GWLP_USERDATA, (LONG_PTR) winPtr);
	tsdPtr->createWindow = NULL;

    Tcl_Obj *const objv[])	/* Argument objects. */
{
    register WmInfo *wmPtr = winPtr->wmInfoPtr;
    LONG style, exStyle, styleBit, *stylePtr = NULL;
    const char *string;
    int i, boolean;
    size_t length;
    int config_fullscreen = 0, config_shadow = 0, updatewrapper = 0;
    int fullscreen_attr_changed = 0, fullscreen_attr = 0;
    int shadow_attr_changed = 0, shadow_attr = 0;

    if ((objc < 3) || ((objc > 5) && ((objc%2) == 0))) {
    configArgs:
	Tcl_WrongNumArgs(interp, 2, objv,
		"window"
		" ?-alpha ?double??"
		" ?-contexthelp ?bool??"
		" ?-disabled ?bool??"
		" ?-fullscreen ?bool??"
		" ?-shadow ?bool??"
		" ?-toolwindow ?bool??"
		" ?-topmost ?bool??"
		" ?-transparentcolor ?color??");
	return TCL_ERROR;
    }
    exStyle = wmPtr->exStyleConfig;
    style = wmPtr->styleConfig;
    if (objc == 3) {
	Tcl_Obj *objPtr = Tcl_NewObj();
	Tcl_ListObjAppendElement(NULL, objPtr,

		Tcl_NewStringObj("-toolwindow", -1));
	Tcl_ListObjAppendElement(NULL, objPtr,
		Tcl_NewWideIntObj((exStyle & WS_EX_TOOLWINDOW) != 0));
	Tcl_ListObjAppendElement(NULL, objPtr,
		Tcl_NewStringObj("-topmost", -1));
	Tcl_ListObjAppendElement(NULL, objPtr,
		Tcl_NewWideIntObj((exStyle & WS_EX_TOPMOST) != 0));
	Tcl_ListObjAppendElement(NULL, objPtr,
		Tcl_NewStringObj("-contexthelp", -1));
	Tcl_ListObjAppendElement(NULL, objPtr,
		Tcl_NewBooleanObj((style & WS_EX_CONTEXTHELP) != 0));
	Tcl_ListObjAppendElement(NULL, objPtr,
		Tcl_NewStringObj("-shadow", -1));
	Tcl_ListObjAppendElement(NULL, objPtr,
		Tcl_NewBooleanObj((wmPtr->flags & WM_DROPSHADOW) != 0));
	Tcl_SetObjResult(interp, objPtr);
	return TCL_OK;
    }
    for (i = 3; i < objc; i += 2) {
	string = Tcl_GetString(objv[i]);
	length = objv[i]->length;
	if ((length < 2) || (string[0] != '-')) {
	    goto configArgs;
	}
	if (strncmp(string, "-disabled", length) == 0) {
	    stylePtr = &style;
	    styleBit = WS_DISABLED;
	} else if ((strncmp(string, "-alpha", length) == 0)
		|| ((length > 2) && (strncmp(string, "-transparentcolor",
			length) == 0))) {
	    stylePtr = &exStyle;
	    styleBit = WS_EX_LAYERED;
	} else if (strncmp(string, "-fullscreen", length) == 0) {
	    config_fullscreen = 1;
	    styleBit = 0;
	} else if (strncmp(string, "-shadow", (unsigned) length) == 0) {
	    config_shadow = 1;
	    styleBit = 0;
	} else if (strncmp(string,"-contexthelp", length) == 0) {
	    stylePtr = &exStyle;
	    styleBit = WS_EX_CONTEXTHELP;
	} else if ((length > 3)
		&& (strncmp(string, "-toolwindow", length) == 0)) {
	    stylePtr = &exStyle;
	    styleBit = WS_EX_TOOLWINDOW;
	    if (objc != 4) {
		/*
		 * Changes to toolwindow style require an update

		    Tcl_SetObjResult(interp, Tcl_NewWideIntObj(
			    (wmPtr->flags & WM_FULLSCREEN) != 0));
		} else {
		    fullscreen_attr_changed = 1;
		    fullscreen_attr = boolean;
		}
		config_fullscreen = 0;
	    } else if (config_shadow) {
		if (objc == 4) {
		    Tcl_SetBooleanObj(Tcl_GetObjResult(interp),
			    (wmPtr->flags & WM_DROPSHADOW) != 0);
		} else {
		    shadow_attr_changed = 1;
		    shadow_attr = boolean;
		}
		config_shadow = 0;
	    } else if (objc == 4) {
		Tcl_SetObjResult(interp,
			Tcl_NewWideIntObj((*stylePtr & styleBit) != 0));
	    } else if (boolean) {
		*stylePtr |= styleBit;
	    } else {
		*stylePtr &= ~styleBit;

			" max width/height is too small", winPtr->pathName));
		Tcl_SetErrorCode(interp, "TK", "WM", "ATTR", "SMALL_MAX", NULL);
		return TCL_ERROR;
	    }
	}

	TkpWmSetFullScreen(winPtr, fullscreen_attr);
    }
    if (shadow_attr_changed) {
	if (shadow_attr) {
	    wmPtr->flags |= WM_DROPSHADOW;
	} else {
	    wmPtr->flags &= ~WM_DROPSHADOW;
	}
	if (!(wmPtr->flags & WM_NEVER_MAPPED)) {
	    UpdateWrapper(winPtr);
	}
    }

    return TCL_OK;
}

/*
 *----------------------------------------------------------------------

    static int oldMode;		/* This static is set upon entering move/size
				 * mode and is used to reset the service mode
				 * after leaving move/size mode. Note that
				 * this mechanism assumes move/size is only
				 * one level deep. */
    LRESULT result = 0;
    TkWindow *winPtr = NULL;
    POINT point;
    int state;

    switch (message) {
    case WM_KILLFOCUS:
    case WM_ERASEBKGND:
	result = 0;
	goto done;

	     */

	    result = HTCLIENT;
	    goto done;
	}
	break;
    }

    case WM_NCLBUTTONDOWN:
    case WM_NCLBUTTONDBLCLK:
    case WM_NCLBUTTONUP:
    case WM_NCMBUTTONDOWN:
    case WM_NCMBUTTONDBLCLK:
    case WM_NCMBUTTONUP:
    case WM_NCRBUTTONDOWN:
    case WM_NCRBUTTONDBLCLK:
    case WM_NCRBUTTONUP: 
	Tk_UpdatePointer(NULL, 0, 0, TkWinGetModifierState() | NOCURSOR_MASK);
	result = (*tkWinProcs->defWindowProc)(hwnd, message, wParam, lParam);
	goto done;

    case WM_MOUSEACTIVATE: {
	winPtr = GetTopLevel((HWND) wParam);
	if (winPtr && (TkGrabState(winPtr) != TK_GRAB_EXCLUDED)) {
	    /*
	     * This allows us to pass the message onto the native menus [Bug:
	     * 2272]

    MessageBeep(MB_OK);
    return Success;
}

/*
 *----------------------------------------------------------------------
 *
 * HelpEvent --
 *
 *	Generates a "Help" virtual event. This can be used to do
 *	context-sensitive help.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Places a virtual event on the event queue.
 *
 *----------------------------------------------------------------------
 */

static void
HelpEvent(
    HWND hwnd,
    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    TkWindow *winPtr = (TkWindow *) Tk_HWNDToWindow(hwnd);
    XVirtualEvent event;
    POINTS rootPoint;
    POINT clientPoint;
    DWORD msgPos;

    event.type = VirtualEvent;
    event.serial = winPtr->display->request;
    event.send_event = 0;
    event.display = winPtr->display;
    event.event = Tk_WindowId(winPtr);
    event.root = XRootWindow(winPtr->display, 0);
    event.subwindow = None;
    event.time = TkpGetMS();

    msgPos = GetMessagePos();
    rootPoint = MAKEPOINTS(msgPos);
    clientPoint.x = rootPoint.x;
    clientPoint.y = rootPoint.y;
    ScreenToClient(hwnd, &clientPoint);
    event.x = clientPoint.x;
    event.y = clientPoint.y;
    event.x_root = rootPoint.x;
    event.y_root = rootPoint.y;
    event.state = TkWinGetModifierState();
    event.same_screen = 1;
    event.name = Tk_GetUid("Help");
    event.user_data = NULL;
    Tk_QueueWindowEvent((XEvent *) &event, TCL_QUEUE_TAIL);
}

/*
 *----------------------------------------------------------------------
 *
 * TkWinChildProc --
 *
 *	Callback from Windows whenever an event occurs on a child window.
 *
 * Results:
 *	Standard Windows return value.
 *

    UINT message,
    WPARAM wParam,
    LPARAM lParam)
{
    LRESULT result;

    switch (message) {
    case WM_HELP:
	Tk_UpdatePointer(NULL, 0, 0,
		TkWinGetModifierState() | NOBUTTONEVENTS_MASK);
	HelpEvent(hwnd, message, wParam, lParam);
	result = DefWindowProc(hwnd, message, wParam, lParam);
	break;

    case WM_INPUTLANGCHANGE:
	UpdateInputLanguage((int) wParam);
	result = 1;
	break;

    case WM_IME_COMPOSITION:
	result = 0;