# Example usage of the touch interface

if 0 {
    The current interface is as follows.

    All configuration is done via:
    wm touch <win> ?options?

    Some gestures are on by default. It seems like all but rotate.
    To get raw touch events, they must be turned on.

    To control gestures:
    -all : Turn on all gestures
    -pressandtap <bool> : Turn on or off PressAndTap gesture
    -rotate <bool> : Turn on or off Rotate gesture
    -twofingertap <bool> : Turn on or off TwoFingerTap gesture
    -zoom <bool> : Turn on or off Zoom gesture
    -pan <bool> : Turn on or off Pan gestures
    -pansfh <bool> : Turn on or off Pan single finger horizontal gesture
    -pansfv <bool> : Turn on or off Pan single finger vertical gesture
    -pangutter <bool> : Turn on or off Pan gutter mode
    -paninertia <bool> : Turn on or off Pan inertial mode
    See GESTURECONFIG in win API for pan flags.

    To get raw touch events:
    If any of the flags -touch, -fine or -wantpalm is given,
    the window is registered to receive raw touch event.
    It will no longer receive any gesture events.
    The flags -fine/-wantpalm corresponds to the Windows API
    RegisterTouchWindow.

    Events are received as virtual events.
    These events support at least base %W %x %y %X %Y fields.
    All extra information is given in a dictionary in the %d field.
    <<FingerDown>> <<FingerUp>> <<FingerMotion>> : Raw touch events
    <<PinchToZoom>> : Zoom gesture
    <<Gesture>>     : Other gestures

    Any boolean field in the dictionary is either present with
    the value 1 or not present. Below they are written without a value.

    Touch fields:
    event = touch : Identify event as a touch. (i.e. not a gesture)
    id <val> : Id to know what events belong to the same touch.
    flags <val> : Raw flags value, in case future flags are provided.
    down : Start of touch
    move : Touch is moving
    up   : End of touch
    primary : First touch in a multi touch. Primary touch might also cause
              button events.
    inrange/nocoalesce/palm : See TOUCHINPUT in Windows API.

    Gesture fields:
    event = gesture : Identify event as a gesture.
    flags <val> : Raw flags value, in case future flags are provided.
    begin : Start of gesture
    end : End of gesture
    inertia : Gesture has triggered inertia

    Note that begin and end can both be set, e.g. in two finger tap.

    gesture <type> : Where type is one of:
      zoom : Zoom gesture. %x/y is between fingers
      pan  : Pan gesture. %x/y is between fingers
      rotate : Rotate gesture. %x/y is between fingers
      twofingertap : Two finger tap gesture. %x/y is between fingers
      pressandtap : Press and tap gesture. %x/y is first finger
    
    distance <i> : For zoom/pan/twofingertap: Distance between fingers.
    angle <r> : For rotate: Rotation angle in radians.
    deltax <i> : For pressandtap: Locates second finger. Valid with begin.
    deltay <i> : For pressandtap: Locates second finger. Valid with begin.
    inertiax <i> : For pan: Inertia vector. Valid with inertia flag.
    inertiay <i> : For pan: Inertia vector. Valid with inertia flag.

}

namespace import tcl::mathop::*

proc rndCol {} {
    set lst {orange yellow green cyan blue purple violet pink}
    set i [expr {int(rand()*[llength $lst])}]
    return [lindex $lst $i]
}

proc Circle {w x y r args} {
    $w create oval [- $x $r] [- $y $r] [+ $x $r] [+ $y $r] \
	-fill "" -outline black -width 2 {*}$args
}

proc Touch1 {W d x y X Y} {
    puts stderr "Touch1: $W $x $y $X $Y"
    puts stderr "Touch1: $d"

    set id [dict get $d id]

    set move [dict exists $d move]
    set down [dict exists $d down]
    set up   [dict exists $d up]
    set primary [dict exists $d primary]

    if {![info exists ::t($id,id)]} {
	set ::t($id,id) [$W create oval $x $y $x $y]
	if {$primary} {
	    $W itemconfigure $::t($id,id) -fill red
	} else {
	    $W itemconfigure $::t($id,id) -fill [rndCol]
	}
    }
    if {$up} {
	$W delete $::t($id,id)
	array unset ::t $id,*
	return
    }

    # Filter unnecessary movement
    if {$move && $x == $::t($id,x) && $y == $::t($id,y)} {
	return
    }
    set r [expr {[winfo screenwidth .] / 50}]
    set ::t($id,x) $x
    set ::t($id,y) $y
    $W coords $::t($id,id) [- $x $r] [- $y $r] [+ $x $r] [+ $y $r]
}

proc Log {W d} {
    # Make a little log of messages for now
    if {[lindex $::messages 9] ne $d} {
	lappend ::messages $d
	set ::messages [lrange $::messages end-9 end]
    }
    set txt [join $::messages \n]
    $W itemconfigure gesture -text $txt
    $W raise gesture
}

proc Touch2 {W d x y X Y} {
    if {[dict get $d event] ne "gesture"} return

    puts stderr "Touch2: $W $x $y $X $Y"
    puts stderr "Touch2: $d"

    switch [dict get $d gesture] {
        twofingertap {
            $W delete twofingertap
            set r [expr {[dict get $d distance] / 2}]
            Circle $W $x $y $r -fill yellow -tags twofingertap
        }
        pressandtap {
            if {[dict exists $d begin]} {
                # Only the begin message has delta set
                $W delete pressandtap
                set x1 [expr {$x + [dict get $d deltax]}]
                set y1 [expr {$y + [dict get $d deltay]}]
                $W create line $x $y $x1 $y1 -width 5 -fill red \
                        -tags pressandtap
            }
            if {[dict exists $d end]} {
                # Make end visible by changing colour
                $W itemconfigure pressandtap -fill purple
            }
        }
        zoom {
            $W delete zoom
            set r [expr {[dict get $d distance] / 2}]
            Circle $W $x $y $r -fill blue -tags zoom
        }
        pan {
            $W delete pan
            set dist [dict get $d distance]
            if {$dist == 0} {
                # Must be one finger?
                set r 40
                set col red
            } else {
                set r [expr {$dist / 2}]
                set col green
            }
            Circle $W $x $y $r -fill $col -tags pan
        }
        rotate {
            $W delete rotate
            set a [expr {180.0*[dict get $d angle]/3.141592 - 20}]
            set r [expr {$::size/4}]
            $W create arc [- $x $r] [- $y $r] [+ $x $r] [+ $y $r] \
                    -fill orange -outline black -width 2 -tags rotate \
                    -start $a -extent 40
        }
    }
    Log $W $d
}

console show
set ::sizew [expr {[winfo screenwidth .] * 0.45}]
set ::sizeh [expr {[winfo screenheight .] * 0.45}]
if {$::sizeh < $::sizew} {
    set ::size [expr round($::sizeh)]
} else {
    set ::size [expr round($::sizew)]
}
canvas .c1 -width $::size -height $::size -bd 3 -relief solid
canvas .c2 -width $::size -height $::size -bd 3 -relief solid
canvas .c3 -width $::size -height $::size -bd 3 -relief solid
.c1 create text [expr {$::size /2}] [expr {$::size /2}] -text Touch
lappend ::messages "Gesture"
.c2 create text [expr {$::size / 2}] [expr {$::size / 2}] -text GestureAll -tags gesture
.c3 create text [expr {$::size / 2}] [expr {$::size / 2}] -text Gesture -tags gesture

grid .c1 -   -sticky news
grid .c2 .c3 -sticky news
grid columnconfigure . all -weight 1
grid rowconfigure . all -weight 1
wm touch .c1 -touch
wm touch .c2 -all
wm touch .c3 -pan 1 -pansfv 0 -pansfh 0 -pangutter 0 -paninertia 0
bind .c1 <<FingerDown>> "Touch1 %W %d %x %y %X %Y"
bind .c1 <<FingerUp>> "Touch1 %W %d %x %y %X %Y"
bind .c1 <<FingerMotion>> "Touch1 %W %d %x %y %X %Y"
bind .c2 <<Gesture>> "Touch2 %W %d %x %y %X %Y"
bind .c2 <<PinchToZoom>> "Touch2 %W %d %x %y %X %Y"
bind .c3 <<Gesture>> "Touch2 %W %d %x %y %X %Y"
bind .c3 <<PinchToZoom>> "Touch2 %W %d %x %y %X %Y"

MODULE_SCOPE int		TkpWmGetState(TkWindow *winPtr);

/*
 * Common routines used in Windows implementation
 */
MODULE_SCOPE Tcl_Obj *	        TkWin32ErrorObj(HRESULT hrError);

/*
 * Touch/gesture event support
 */
MODULE_SCOPE int		TkWinGenerateTouchEvent(HWND hwnd, WPARAM wParam, LPARAM lParam);
MODULE_SCOPE int		TkWinGenerateGestureEvent(HWND hwnd, WPARAM wParam, LPARAM lParam);

/*
 * The following functions are not present in old versions of Windows
 * API headers but are used in the Tk source to ensure 64bit
 * compatibility.
 */

    if (keycode > MAX_KEYCODE) {
	return NoSymbol;
    }
    switch (keycode) {
	/*
	 * Windows only gives us an undifferentiated VK_CONTROL code (for
	 * example) when either Control key is pressed. To distinguish between
	 * left and right, we use the Extended flag. Indeed, the right Control
	 * and Alt (aka Menu) keys are such extended keys (which their left
	 * counterparts are not).
	 * Regarding the shift case, Windows does not set the Extended flag for
	 * the neither the left nor the right shift key. As a consequence another
	 * way to distinguish between the two keys is to query the state of one
	 * of the two to determine which was actually pressed. So if the keycode

	 * indicates Shift, do this extra test. If the right-side key was
	 * pressed, return the appropriate keycode. Otherwise, we fall through
	 * and rely on the keymap table to hold the correct keysym value.
	 * Note: this little trick only works for KeyPress, not for KeyRelease,
	 * for reasons stated in bug [2945130]
	 */

    case VK_CONTROL:
        if (state & EXTENDED_MASK) {
            return XK_Control_R;
        }
	break;
    case VK_SHIFT:
	if (GetKeyState(VK_RSHIFT) & 0x80) {
	    return XK_Shift_R;
	}
	break;
    case VK_MENU:
        if (state & EXTENDED_MASK) {
            return XK_Alt_R;
        }
	break;
    }
    return keymap[keycode];
}

/*
 *----------------------------------------------------------------------

 */

static int initialized;		/* Flag indicating whether module has been
				 * initialized. */

TCL_DECLARE_MUTEX(winWmMutex)

#if (_WIN32_WINNT >= 0x0601)

/*
 * Helpers for touch event to fill in its dictionary.
 */

#define ADD_DICT_STR(d, s, v)						\
    Tcl_DictObjPut(NULL, d, Tcl_NewStringObj(s, -1), Tcl_NewStringObj(v, -1))
#define ADD_DICT_INT(d, s, v)						\
    Tcl_DictObjPut(NULL, d, Tcl_NewStringObj(s, -1), Tcl_NewIntObj(v))
#define ADD_DICT_WIDE(d, s, v) \
    Tcl_DictObjPut(NULL, d, Tcl_NewStringObj(s, -1), Tcl_NewWideIntObj(v))
#define ADD_DICT_DOUB(d, s, v) \
    Tcl_DictObjPut(NULL, d, Tcl_NewStringObj(s, -1), Tcl_NewDoubleObj(v))

/*
 * Touch/gesture event Windows APIs.
 */

typedef WINBOOL (WINAPI CloseTouchInputHandleProc)(HANDLE);
typedef WINBOOL (WINAPI GetTouchInputInfoProc)(HANDLE, UINT, PTOUCHINPUT, int);
typedef WINBOOL (WINAPI RegisterTouchWindowProc)(HWND, ULONG);
typedef WINBOOL (WINAPI UnregisterTouchWindowProc)(HWND);
typedef WINBOOL (WINAPI GetGestureInfoProc)(HGESTUREINFO, PGESTUREINFO);
typedef WINBOOL (WINAPI SetGestureConfigProc)(HWND, DWORD, UINT,
				PGESTURECONFIG, UINT);

static CloseTouchInputHandleProc	*pCloseTouchInputHandle;
static GetTouchInputInfoProc		*pGetTouchInputInfo;
static RegisterTouchWindowProc		*pRegisterTouchWindow;
static UnregisterTouchWindowProc	*pUnregisterTouchWindow;
static GetGestureInfoProc		*pGetGestureInfo;
static SetGestureConfigProc		*pSetGestureConfig;

#ifndef TWF_FINETOUCH
#define TWF_FINETOUCH 1
#endif

#ifndef TWF_WANTPALM
#define TWF_WANTPALM 2 
#endif

#ifndef TOUCH_COORD_TO_PIXEL
#define TOUCH_COORD_TO_PIXEL(c) ((c) / 100)
#endif

#endif

/*
 * Forward declarations for functions defined in this file:
 */

static int		ActivateWindow(Tcl_Event *evPtr, int flags);
static void		ConfigureTopLevel(WINDOWPOS *pos);
static void		GenerateConfigureNotify(TkWindow *winPtr);

			    Tcl_Obj *const objv[]);
static int		WmStateCmd(Tk_Window tkwin,
			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
			    Tcl_Obj *const objv[]);
static int		WmTitleCmd(Tk_Window tkwin,
			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
			    Tcl_Obj *const objv[]);
static int		WmTouchCmd(Tk_Window tkwin,
			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
			    Tcl_Obj *const objv[]);
static int		WmTransientCmd(Tk_Window tkwin,
			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
			    Tcl_Obj *const objv[]);
static int		WmWithdrawCmd(Tk_Window tkwin,
			    TkWindow *winPtr, Tcl_Interp *interp, int objc,
			    Tcl_Obj *const objv[]);
static void		WmUpdateGeom(WmInfo *wmPtr, TkWindow *winPtr);

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

	    if (!RegisterClass(&class)) {
		Tcl_Panic("Unable to register TkTopLevel class");
	    }
#if (_WIN32_WINNT >= 0x0601)
	    {
		HANDLE lib = LoadLibrary(TEXT("user32.dll"));

		if (lib != NULL) {
		    pCloseTouchInputHandle = (CloseTouchInputHandleProc *)
			GetProcAddress(lib, "CloseTouchInputHandle");
		    pGetTouchInputInfo = (GetTouchInputInfoProc *)
			GetProcAddress(lib, "GetTouchInputInfo");
		    pRegisterTouchWindow = (RegisterTouchWindowProc *)
			GetProcAddress(lib, "RegisterTouchWindow");
		    pUnregisterTouchWindow = (UnregisterTouchWindowProc *)
			GetProcAddress(lib, "UnregisterTouchWindow");
		    pGetGestureInfo = (GetGestureInfoProc *)
			GetProcAddress(lib, "GetGestureInfo");
		    pSetGestureConfig = (SetGestureConfigProc *)
			GetProcAddress(lib, "SetGestureConfig");
		}
		FreeLibrary(lib);
	    }
#endif
	}
	Tcl_MutexUnlock(&winWmMutex);
    }
    return TCL_OK;
}

/*

	"aspect", "attributes", "client", "colormapwindows",
	"command", "deiconify", "focusmodel", "forget", "frame",
	"geometry", "grid", "group", "iconbitmap",
	"iconify", "iconmask", "iconname",
	"iconphoto", "iconposition",
	"iconwindow", "manage", "maxsize", "minsize", "overrideredirect",
	"positionfrom", "protocol", "resizable", "sizefrom",
	"stackorder", "state", "title", "touch", "transient",
	"withdraw", NULL
    };
    enum options {
	WMOPT_ASPECT, WMOPT_ATTRIBUTES, WMOPT_CLIENT, WMOPT_COLORMAPWINDOWS,
	WMOPT_COMMAND, WMOPT_DEICONIFY, WMOPT_FOCUSMODEL, WMOPT_FORGET,
	WMOPT_FRAME,
	WMOPT_GEOMETRY, WMOPT_GRID, WMOPT_GROUP, WMOPT_ICONBITMAP,
	WMOPT_ICONIFY, WMOPT_ICONMASK, WMOPT_ICONNAME,
	WMOPT_ICONPHOTO, WMOPT_ICONPOSITION,
	WMOPT_ICONWINDOW, WMOPT_MANAGE, WMOPT_MAXSIZE, WMOPT_MINSIZE,
	WMOPT_OVERRIDEREDIRECT,
	WMOPT_POSITIONFROM, WMOPT_PROTOCOL, WMOPT_RESIZABLE, WMOPT_SIZEFROM,
	WMOPT_STACKORDER, WMOPT_STATE, WMOPT_TITLE, WMOPT_TOUCH, WMOPT_TRANSIENT,
	WMOPT_WITHDRAW
    };
    int index;
    size_t length;
    const char *argv1;
    TkWindow *winPtr, **winPtrPtr = &winPtr;
    TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr;

    }

    if (TkGetWindowFromObj(interp, tkwin, objv[2], (Tk_Window *) winPtrPtr)
	    != TCL_OK) {
	return TCL_ERROR;
    }
    if (!Tk_IsTopLevel(winPtr) && (index != WMOPT_MANAGE)
	    && (index != WMOPT_TOUCH) && (index != WMOPT_FORGET)) {
	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
		"window \"%s\" isn't a top-level window", winPtr->pathName));
	Tcl_SetErrorCode(interp, "TK", "LOOKUP", "TOPLEVEL", winPtr->pathName,
		NULL);
	return TCL_ERROR;
    }

	return WmSizefromCmd(tkwin, winPtr, interp, objc, objv);
    case WMOPT_STACKORDER:
	return WmStackorderCmd(tkwin, winPtr, interp, objc, objv);
    case WMOPT_STATE:
	return WmStateCmd(tkwin, winPtr, interp, objc, objv);
    case WMOPT_TITLE:
	return WmTitleCmd(tkwin, winPtr, interp, objc, objv);
    case WMOPT_TOUCH:
	return WmTouchCmd(tkwin, winPtr, interp, objc, objv);
    case WMOPT_TRANSIENT:
	return WmTransientCmd(tkwin, winPtr, interp, objc, objv);
    case WMOPT_WITHDRAW:
	return WmWithdrawCmd(tkwin, winPtr, interp, objc, objv);
    }

    /* This should not happen */

    if (Tk_IsTopLevel(frameWin)) {
	Tk_UnmapWindow(frameWin);
	winPtr->flags &= ~(TK_TOP_HIERARCHY|TK_TOP_LEVEL|TK_HAS_WRAPPER|TK_WIN_MANAGED);
	Tk_MakeWindowExist((Tk_Window)winPtr->parentPtr);
	RemapWindows(winPtr, Tk_GetHWND(winPtr->parentPtr->window));

	/*
	 * Make sure wm no longer manages this window
	 */
	Tk_ManageGeometry(frameWin, NULL, NULL);

	TkWmDeadWindow(winPtr);
	/* flags (above) must be cleared before calling */
	/* TkMapTopFrame (below) */
	TkMapTopFrame(frameWin);
    } else {
	/* Already not managed by wm - ignore it */

	    Tcl_WinUtfToTChar(wmPtr->title, -1, &titleString);
	    SetWindowText(wrapper, (LPCTSTR) Tcl_DStringValue(&titleString));
	    Tcl_DStringFree(&titleString);
	}
    }
    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * WmTouchCmd --
 *
 *	This function is invoked to process the "wm touch" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

static int
WmTouchCmd(
    Tk_Window tkwin,		/* Main window of the application. */
    TkWindow *winPtr,		/* Toplevel to work with */
    Tcl_Interp *interp,		/* Current interpreter. */
    int objc,			/* Number of arguments. */
    Tcl_Obj *const objv[])	/* Argument objects. */
{
#if (_WIN32_WINNT >= 0x0601)
    Window win;
    HWND hwnd;
    int i, index, gCnt = 0, value;
    ULONG flags = 0;
    int touch = 0, panFlag;
    GESTURECONFIG gcPan = { 0, 0, 0 };
    GESTURECONFIG gc[16];
    static const char *const optionStrings[] = {
	"-all", "-fine", "-pan", "-pangutter", "-paninertia",
	"-pansfh", "-pansfv", "-pressandtap", "-rotate",
	"-touch", "-twofingertap", "-wantpalm", "-zoom",
	"-notouch", "-none", NULL
    };
    enum options {
	TOUCH_ALL, TOUCH_FINE, TOUCH_PAN, TOUCH_PANGUTTER, TOUCH_PANINERTIA,
	TOUCH_PANSFH, TOUCH_PANSFV, TOUCH_PRESSANDTAP, TOUCH_ROTATE,
	TOUCH_TOUCH, TOUCH_TWOFINGERTAP, TOUCH_WANTPALM, TOUCH_ZOOM,
	TOUCH_NOTOUCH, TOUCH_NONE,
    };

    if (objc < 3) {
	Tcl_WrongNumArgs(interp, 2, objv, "window ?-option value ...?");
	return TCL_ERROR;
    }
    ZeroMemory(&gc, sizeof(gc));
    for (i = 3; i < objc; i++) {
	if (Tcl_GetIndexFromObj(interp, objv[i], optionStrings, "option", 0,
				&index) != TCL_OK) {
	    return TCL_ERROR;
	}
	switch ((enum options) index) {
	case TOUCH_ALL:
	    gc[gCnt++].dwWant = GC_ALLGESTURES;
	    break;
	case TOUCH_NONE:
	    gc[gCnt++].dwBlock = GC_ALLGESTURES;
	    break;
	case TOUCH_FINE:
	    flags |= TWF_FINETOUCH;
	    touch = 1;
	    break;
	case TOUCH_PAN:
	    panFlag = GC_PAN;
	    goto pan;
	case TOUCH_PANGUTTER:
	    panFlag = GC_PAN_WITH_GUTTER;
	    goto pan;
	case TOUCH_PANINERTIA:
	    panFlag = GC_PAN_WITH_INERTIA;
	    goto pan;
	case TOUCH_PANSFH:
	    panFlag = GC_PAN_WITH_SINGLE_FINGER_HORIZONTALLY;
	    goto pan;
	case TOUCH_PANSFV:
	    panFlag = GC_PAN_WITH_SINGLE_FINGER_VERTICALLY;
	pan:
	    if (++i >= objc) {
		Tcl_SetObjResult(interp, Tcl_NewStringObj(
			"missing value", -1));
		return TCL_ERROR;
	    }
	    if (Tcl_GetBooleanFromObj(interp, objv[i], &value) != TCL_OK) {
		return TCL_ERROR;
	    }
	    gcPan.dwID = GID_PAN;
	    if (value) {
		gcPan.dwWant |= panFlag;
	    } else {
		gcPan.dwBlock |= panFlag;
	    }
	    break;
	case TOUCH_PRESSANDTAP:
	    if (++i >= objc) {
		Tcl_SetObjResult(interp, Tcl_NewStringObj(
			"missing pressandtap", -1));
		return TCL_ERROR;
	    }
	    if (Tcl_GetBooleanFromObj(interp, objv[i], &value) != TCL_OK) {
		return TCL_ERROR;
	    }
	    gc[gCnt].dwID = GID_PRESSANDTAP;
	    if (value) {
		gc[gCnt++].dwWant = GC_PRESSANDTAP;
	    } else {
		gc[gCnt++].dwBlock = GC_PRESSANDTAP;
	    }
	    break;
	case TOUCH_ROTATE:
	    if (++i >= objc) {
		Tcl_SetObjResult(interp, Tcl_NewStringObj(
			"missing rotate", -1));
		return TCL_ERROR;
	    }
	    if (Tcl_GetBooleanFromObj(interp, objv[i], &value) != TCL_OK) {
		return TCL_ERROR;
	    }
	    gc[gCnt].dwID = GID_ROTATE;
	    if (value) {
		gc[gCnt++].dwWant = GC_ROTATE;
	    } else {
		gc[gCnt++].dwBlock = GC_ROTATE;
	    }
	    break;
	case TOUCH_TOUCH:
	    touch = 1;
	    break;
	case TOUCH_TWOFINGERTAP:
	    if (++i >= objc) {
		Tcl_SetObjResult(interp, Tcl_NewStringObj(
			"missing pressandtap", -1));
		return TCL_ERROR;
	    }
	    if (Tcl_GetBooleanFromObj(interp, objv[i], &value) != TCL_OK) {
		return TCL_ERROR;
	    }
	    gc[gCnt].dwID = GID_TWOFINGERTAP;
	    if (value) {
		gc[gCnt++].dwWant = GC_TWOFINGERTAP;
	    } else {
		gc[gCnt++].dwBlock = GC_TWOFINGERTAP;
	    }
	    break;
	case TOUCH_WANTPALM:
	    flags |= TWF_WANTPALM;
	    touch = 1;
	    break;
	case TOUCH_ZOOM:
	    if (++i >= objc) {
		Tcl_SetObjResult(interp, Tcl_NewStringObj(
			"missing zoom", -1));
		return TCL_ERROR;
	    }
	    if (Tcl_GetBooleanFromObj(interp, objv[i], &value) != TCL_OK) {
		return TCL_ERROR;
	    }
	    gc[gCnt].dwID = GID_ZOOM;
	    if (value) {
		gc[gCnt++].dwWant = GC_ZOOM;
	    } else {
		gc[gCnt++].dwBlock = GC_ZOOM;
	    }
	    break;
	case TOUCH_NOTOUCH:
	    touch = -1;
	    break;
	}
	if (gCnt >= sizeof (gc) / sizeof (gc[0]) - 1) {
	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
			"touch config overflow", -1));
	    return TCL_ERROR;
	}
    }

    if (gcPan.dwID != 0) {
	gc[gCnt++] = gcPan;
    }

    win = Tk_WindowId((Tk_Window) winPtr);
    if (win == None) {
	Tk_MakeWindowExist((Tk_Window) winPtr);
	win = Tk_WindowId((Tk_Window) winPtr);
    }

    hwnd = Tk_GetHWND(win);

    if (touch > 0) {
	if (pRegisterTouchWindow != NULL) {
	    pRegisterTouchWindow(hwnd, flags);
	}
    } else if (touch < 0) {
	if (pUnregisterTouchWindow != NULL) {
	    pUnregisterTouchWindow(hwnd);
	}
    }
    if (gCnt > 0) {
	if (pSetGestureConfig != NULL) {
	    pSetGestureConfig(hwnd, 0, gCnt, gc, sizeof(GESTURECONFIG));
	}
    }
#endif
    return TCL_OK;
}

/*
 *----------------------------------------------------------------------
 *
 * WmTransientCmd --
 *
 *	This function is invoked to process the "wm transient" Tcl command.

    for (childPtr = winPtr->childList; childPtr != NULL;
	    childPtr = childPtr->nextPtr) {
	RemapWindows(childPtr,
		winPtr->window ? Tk_GetHWND(winPtr->window) : NULL);
    }
}

/*
 *----------------------------------------------------------------------
 *
 * InitTouchEvent --
 *
 *	This function initialises an event structure with the base
 *	fields used in a TouchEvent.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

#if (_WIN32_WINNT >= 0x0601)
static void
InitTouchEvent(XEvent *event, HWND hwnd, int rootx, int rooty)
{
    POINT sInput, cInput;
    Tk_Window tkwin;
    TkWindow *winPtr;

    sInput.x = rootx;
    sInput.y = rooty;
    cInput = sInput;
    ScreenToClient(hwnd, &cInput);

    tkwin = Tk_HWNDToWindow(hwnd);
    winPtr = (TkWindow *)tkwin;
    memset(event, 0, sizeof(*event));
    event->xany.type = VirtualEvent;
    event->xany.serial =
	LastKnownRequestProcessed(winPtr->display);
    event->xany.send_event = False;
    event->xany.window = Tk_WindowId(tkwin);
    event->xany.display = winPtr->display;
    event->xkey.root =
	RootWindow(winPtr->display,winPtr->screenNum);
    event->xkey.x_root = sInput.x;
    event->xkey.y_root = sInput.y;
    event->xkey.x = cInput.x;
    event->xkey.y = cInput.y;
}
#endif

/*
 *----------------------------------------------------------------------
 *
 * TkWinGenerateTouchEvent --
 *
 *	This function generate touch events when a WM_TOUCH event has
 *      been received.
 *
 * Results:
 *	Returns 1 if the event was handled, else 0.
 *
 * Side effects:
 *	May queue one or more X events.
 *
 *----------------------------------------------------------------------
 */

int
TkWinGenerateTouchEvent(
    HWND hwnd,
    WPARAM wParam,
    LPARAM lParam)
{
#if (_WIN32_WINNT >= 0x0601)
    BOOL bHandled = FALSE;
    UINT cInputs = LOWORD(wParam);
    PTOUCHINPUT pInputs = ckalloc(sizeof(TOUCHINPUT)*cInputs);
    union {XEvent general; XVirtualEvent virtual;} event;
    Tcl_Obj *dictPtr;

    if (pGetTouchInputInfo == NULL) {
	return 0;
    }
    if (pInputs != NULL) {
	if (pGetTouchInputInfo((HANDLE)lParam,
			       cInputs,
			       pInputs,
			       sizeof(TOUCHINPUT))) {
	    UINT i;

	    for (i = 0; i < cInputs; i++) {
		TOUCHINPUT ti = pInputs[i];
		InitTouchEvent(&event.general, hwnd,
			       TOUCH_COORD_TO_PIXEL(ti.x),
			       TOUCH_COORD_TO_PIXEL(ti.y));
		/*
		 * Which info needs to be passed to the event, and how should
		 * is be passed ?
		 * Put it into a dict and pass it through %d
		 */
		dictPtr = Tcl_NewDictObj();
		Tcl_IncrRefCount(dictPtr);
		/* Identify as a touch event */
		ADD_DICT_STR(dictPtr, "event", "touch");
		/* Touch ID */
		ADD_DICT_INT(dictPtr, "id", ti.dwID);
		/* Raw flags value */
		ADD_DICT_INT(dictPtr, "flags", ti.dwFlags);
		/* Decode known flags */
		if (ti.dwFlags & TOUCHEVENTF_MOVE) {
		    ADD_DICT_INT(dictPtr, "move", 1);
		    event.virtual.name = Tk_GetUid("FingerMotion");
		}
		if (ti.dwFlags & TOUCHEVENTF_DOWN) {
		    ADD_DICT_INT(dictPtr, "down", 1);
		    event.virtual.name = Tk_GetUid("FingerDown");
		}
		if (ti.dwFlags & TOUCHEVENTF_UP) {
		    ADD_DICT_INT(dictPtr, "up", 1);
		    event.virtual.name = Tk_GetUid("FingerUp");
		}
		if (ti.dwFlags & TOUCHEVENTF_INRANGE) {
		    ADD_DICT_INT(dictPtr, "inrange", 1);
		}
		if (ti.dwFlags & TOUCHEVENTF_PRIMARY) {
		    ADD_DICT_INT(dictPtr, "primary", 1);
		}
		if (ti.dwFlags & TOUCHEVENTF_NOCOALESCE) {
		    ADD_DICT_INT(dictPtr, "nocoalesce", 1);
		}
		if (ti.dwFlags & TOUCHEVENTF_PALM) {
		    ADD_DICT_INT(dictPtr, "palm", 1);
		}
		event.virtual.user_data = dictPtr;
		Tk_QueueWindowEvent(&event.general, TCL_QUEUE_TAIL);
	    }
	    bHandled = TRUE;
	}
	ckfree(pInputs);
    }
    if (bHandled) {
	pCloseTouchInputHandle((HANDLE)lParam);
	return 1;
    }
#endif
    return 0;
}

/*
 *----------------------------------------------------------------------
 *
 * TkWinGenerateGestureEvent --
 *
 *	This function generate touch events when a WM_GESTURE event has
 *      been received.
 *
 * Results:
 *	Returns 1 if the event was handled, else 0.
 *
 * Side effects:
 *	May queue an X event.
 *
 *----------------------------------------------------------------------
 */

int
TkWinGenerateGestureEvent(
    HWND hwnd,
    WPARAM wParam,
    LPARAM lParam)
{
#if (_WIN32_WINNT >= 0x0601)
    GESTUREINFO gi;
    union {XEvent general; XVirtualEvent virtual;} event;
    Tcl_Obj *dictPtr;
    POINT sLoc, delta;
    POINTS pts;
    UINT LInt, HInt;

    if (pGetGestureInfo == NULL) {
	return 0;
    }

    ZeroMemory(&gi, sizeof(GESTUREINFO));
    gi.cbSize = sizeof(GESTUREINFO);

    if (!pGetGestureInfo((HGESTUREINFO)lParam, &gi)) {
	return 0;
    }

    /* Is it something we want to handle? */
    switch (gi.dwID) {
    case GID_BEGIN:
    case GID_END:
	/* These should not be handled */
	return 0;
    case GID_ZOOM:
    case GID_PAN:
    case GID_ROTATE:
    case GID_TWOFINGERTAP:
    case GID_PRESSANDTAP:
	break;
    default:
	/* A gesture was not recognized */
	return 0;
    }

    POINTSTOPOINT(sLoc, gi.ptsLocation);

    InitTouchEvent(&event.general, hwnd, sLoc.x, sLoc.y);
    event.virtual.name = Tk_GetUid("Gesture");
    dictPtr = Tcl_NewDictObj();
    Tcl_IncrRefCount(dictPtr);
    /* Identify as a gesture event */
    ADD_DICT_STR(dictPtr, "event", "gesture");
    /* Raw flags value */
    ADD_DICT_INT(dictPtr, "flags", gi.dwFlags);
    /* Decode known flags */
    if (gi.dwFlags & GF_BEGIN) {
	ADD_DICT_INT(dictPtr, "begin", 1);
    }
    if (gi.dwFlags & GF_INERTIA) {
	ADD_DICT_INT(dictPtr, "inertia", 1);
    }
    if (gi.dwFlags & GF_END) {
	ADD_DICT_INT(dictPtr, "end", 1);
    }

    LInt = (UINT) (gi.ullArguments & 0xFFFFFFFF);
    HInt = (UINT) (gi.ullArguments >> 32);
    switch (gi.dwID) {
    case GID_ZOOM:
	ADD_DICT_STR(dictPtr, "gesture", "zoom");
	ADD_DICT_WIDE(dictPtr, "distance", gi.ullArguments);
	event.virtual.name = Tk_GetUid("PinchToZoom");
	break;
    case GID_PAN:
	ADD_DICT_STR(dictPtr, "gesture", "pan");
	ADD_DICT_WIDE(dictPtr, "distance", LInt);
	if (gi.dwFlags & GF_INERTIA) {
	    pts = MAKEPOINTS(HInt);
	    ADD_DICT_INT(dictPtr, "inertiax", pts.x);
	    ADD_DICT_INT(dictPtr, "inertiay", pts.y);
	}
	break;
    case GID_ROTATE:
	ADD_DICT_STR(dictPtr, "gesture", "rotate");
	ADD_DICT_DOUB(dictPtr, "angle",
		      GID_ROTATE_ANGLE_FROM_ARGUMENT(gi.ullArguments));
	break;
    case GID_TWOFINGERTAP:
	ADD_DICT_STR(dictPtr, "gesture", "twofingertap");
	ADD_DICT_WIDE(dictPtr, "distance", gi.ullArguments);
	break;
    case GID_PRESSANDTAP:
	ADD_DICT_STR(dictPtr, "gesture", "pressandtap");
	pts = MAKEPOINTS(LInt);
	POINTSTOPOINT(delta, pts);
	ADD_DICT_INT(dictPtr, "deltax", delta.x);
	ADD_DICT_INT(dictPtr, "deltay", delta.y);
	break;
    }
    event.virtual.user_data = dictPtr;
    Tk_QueueWindowEvent(&event.general, TCL_QUEUE_TAIL);
    return 1;
#else
    return 0;
#endif
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

 * Perhaps this definition should be moved in another file.
 */
#ifndef WM_UNICHAR
#define WM_UNICHAR     0x0109
#define UNICODE_NOCHAR 0xFFFF
#endif

#if (_WIN32_WINNT >= 0x0601)
#ifndef WM_TOUCH
#define WM_TOUCH       0x0240
#endif
#endif

/*
 * Declarations of static variables used in this file.
 */

static const char winScreenName[] = ":0"; /* Default name of windows display. */
static HINSTANCE tkInstance = NULL;	/* Application instance handle. */
static int childClassInitialized;	/* Registered child class? */

 * specific date for threads.
 */

typedef struct ThreadSpecificData {
    TkDisplay *winDisplay;	/* TkDisplay structure that represents Windows
				 * screen. */
    int updatingClipboard;	/* If 1, we are updating the clipboard. */
#if TCL_UTF_MAX >= 4
    int surrogateBuffer;	/* Buffer for first of surrogate pair. */
#endif
} ThreadSpecificData;
static Tcl_ThreadDataKey dataKey;

/*
 * Forward declarations of functions used in this file.
 */

    case TK_SETMENU:
    case TK_STATE:
    case TK_INFO:
	result = TkWinEmbeddedEventProc(hwnd, message, wParam, lParam);
	break;

    case WM_UNICHAR:
	if (wParam == UNICODE_NOCHAR) {
	    /* If wParam is UNICODE_NOCHAR and the application processes
	     * this message, then return TRUE. */
	    result = 1;
	} else {
	    /* If the event was translated, we must return 0 */
	    if (Tk_TranslateWinEvent(hwnd, message, wParam, lParam, &result)) {
		result = 0;
	    } else {
		result = 1;
	    }
	}
	break;

    default:
	if (!Tk_TranslateWinEvent(hwnd, message, wParam, lParam, &result)) {
	    result = DefWindowProc(hwnd, message, wParam, lParam);

    case WM_RBUTTONDBLCLK:
    case WM_LBUTTONUP:
    case WM_MBUTTONUP:
    case WM_RBUTTONUP:
    case WM_MOUSEMOVE:
	Tk_PointerEvent(hwnd, (short) LOWORD(lParam), (short) HIWORD(lParam));
	return 1;

#if (_WIN32_WINNT >= 0x0601)
    case WM_TOUCH:
	return TkWinGenerateTouchEvent(hwnd, wParam, lParam);
    case WM_GESTURE:
	return TkWinGenerateGestureEvent(hwnd, wParam, lParam);
#endif

    case WM_SYSKEYDOWN:
    case WM_KEYDOWN:
	if (wParam == VK_PACKET) {
	    /*
	     * This will trigger WM_CHAR event(s) with unicode data.
	     */
	    *resultPtr =
		PostMessageW(hwnd, message, HIWORD(lParam), LOWORD(lParam));
	    return 1;
	}
	/* else fall through */
    case WM_CLOSE:
    case WM_SETFOCUS:
    case WM_KILLFOCUS:
    case WM_DESTROYCLIPBOARD:
    case WM_UNICHAR:
    case WM_CHAR:

    case WM_SYSKEYUP:

    case WM_KEYUP:
    case WM_MOUSEWHEEL:
	GenerateXEvent(hwnd, message, wParam, lParam);
	return 1;
    case WM_MENUCHAR:
	GenerateXEvent(hwnd, message, wParam, lParam);

	    event.type = KeyPress;
	    event.xany.send_event = -1;
	    event.xkey.keycode = 0;
	    if ((int)wParam & 0xff00) {
		int i, ch1 = wParam & 0xffff;
		char buffer[TCL_UTF_MAX+1];



#if TCL_UTF_MAX >= 4
		if ((ch1 & 0xfc00) == 0xd800) {



		    tsdPtr->surrogateBuffer = ch1;
		    return;
		}

		if ((ch1 & 0xfc00) == 0xdc00) {




		    ch1 = ((tsdPtr->surrogateBuffer & 0x3ff) << 10) |
			  (ch1 & 0x3ff);
		    ch1 += 0x10000;
		    tsdPtr->surrogateBuffer = 0;
		}
#endif



		event.xkey.nbytes = Tcl_UniCharToUtf(ch1, buffer);

		for (i=0; i<event.xkey.nbytes && i<XMaxTransChars; ++i) {
		    event.xkey.trans_chars[i] = buffer[i];
		}
		event.xany.send_event = -3;
	    } else {
		event.xkey.nbytes = 1;
		event.xkey.trans_chars[0] = (char) wParam;

	case WM_UNICHAR: {
	    char buffer[TCL_UTF_MAX+1];
	    int i;

	    event.type = KeyPress;
	    event.xany.send_event = -3;

#if TCL_UTF_MAX < 4
	    if ((int) wParam > 0xFFFF) {
		int high =


		    (((((int) wParam) - 0x10000) >> 10) & 0x3FF) | 0xD800;


		wParam = ((((int) wParam) - 0x10000) & 0x3FF) | 0xDC00;
		event.xkey.keycode = high;
		event.xkey.nbytes = Tcl_UniCharToUtf(high, buffer);

		for (i=0; i<event.xkey.nbytes && i<XMaxTransChars; ++i) {
		    event.xkey.trans_chars[i] = buffer[i];
		}
		Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
		event.type = KeyRelease;
		Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
		event.type = KeyPress;
	    }
#endif
	    event.xkey.keycode = wParam;
	    event.xkey.nbytes = Tcl_UniCharToUtf((int)wParam, buffer);

	    for (i=0; i<event.xkey.nbytes && i<XMaxTransChars; ++i) {
		event.xkey.trans_chars[i] = buffer[i];
	    }
	    Tk_QueueWindowEvent(&event, TCL_QUEUE_TAIL);
	    event.type = KeyRelease;
	    break;
	}

	}
	if (prevState) {
	    state |= mask;
	} else {
	    state &= ~mask;
	}
	if (HIWORD(lParam) & KF_EXTENDED) {

	    state |= EXTENDED_MASK;



	}
    }
    return state;
}

/*
 *----------------------------------------------------------------------

  # use -march=i386 -mtune=i386 for Win2000 and/or old CPUs w/o
  # SSE like VIA C3 
  echo using toolchain from /opt/mingw64/bin
  PATH="/opt/mingw64/bin:$PATH"
  STRIP="x86_64-w64-mingw32-strip"
  AR="x86_64-w64-mingw32-ar"
  RANLIB="x86_64-w64-mingw32-ranlib"
  CC="x86_64-w64-mingw32-gcc -m32 -march=i386 -mtune=i386 -D_WIN32_WINNT=0x0601 -DTCL_UTF_MAX=6"
  CXX="x86_64-w64-mingw32-g++ -m32 -march=i386 -mtune=i386 -fno-exceptions -D_WIN32_WINNT=0x0601 -DTCL_UTF_MAX=6"
  RC="x86_64-w64-mingw32-windres -F pe-i386"
  NM="x86_64-w64-mingw32-nm"
  export STRIP AR RANLIB CC CXX RC NM
else
  # would like to use -march=i386 -mtune=i386, too, but then gcc-4.8
  # cannot link due to missing atomic support for this CPU, thus must
  # have Pentium at least
  echo using toolchain prefix i686-w64-mingw32
  STRIP="i686-w64-mingw32-strip"
  AR="i686-w64-mingw32-ar"
  RANLIB="i686-w64-mingw32-ranlib"
  CC="i686-w64-mingw32-gcc -m32 -march=i586 -mtune=generic -D_WIN32_WINNT=0x0601 -DTCL_UTF_MAX=6"
  CXX="i686-w64-mingw32-g++ -m32 -march=i586 -mtune=generic -fno-exceptions -D_WIN32_WINNT=0x0601 -DTCL_UTF_MAX=6"
  RC="i686-w64-mingw32-windres -F pe-i386"
  NM="i686-w64-mingw32-nm"
  TWAPI_LDFLAGS="-L${AWDIR}/undroid/compat/win32/lib32"
  export STRIP AR RANLIB CC CXX RC NM TWAPI_LDFLAGS
fi

SUBDIRS="tcl libressl zlib curl tcludp tdom tclvfs tclkit trofs tbcload tls"

  echo >&3 "done"
) || fail

echo -n "build tclwmf ... "
(
  exec 3>&1
  exec >> build.log 2>&1
  CC=`echo $CC | sed -e 's/-D_WIN32_WINNT=0x[0-9]\+//g'`
  cd tclwmf
  test -e build-stamp && echo >&3 "already done" && exit 0
  DESTDIR=${HERE} ./configure --build=i386-windows-mingw32 --prefix=${PFX} \
    --with-tcl=${HERE}/tcl/win --with-tk=${HERE}/sdl2tk/win \
    --enable-threads || exit 1
  make || exit 1
  make install-binaries install-libraries DESTDIR=${HERE} || exit 1

# the toolchain
if test -d /opt/mingw64/bin ; then
  echo using toolchain from /opt/mingw64/bin
  PATH="/opt/mingw64/bin:$PATH"
  STRIP="x86_64-w64-mingw32-strip"
  AR="x86_64-w64-mingw32-ar"
  RANLIB="x86_64-w64-mingw32-ranlib"
  CC="x86_64-w64-mingw32-gcc -D_WIN32_WINNT=0x0601 -DTCL_UTF_MAX=6"
  CXX="x86_64-w64-mingw32-g++ -D_WIN32_WINNT=0x0601 -DTCL_UTF_MAX=6"
  RC="x86_64-w64-mingw32-windres"
  NM="x86_64-w64-mingw32-nm"
  export STRIP AR RANLIB CC CXX RC NM
else
  echo using toolchain prefix x86_64-w64-mingw32
  STRIP="x86_64-w64-mingw32-strip"
  AR="x86_64-w64-mingw32-ar"
  RANLIB="x86_64-w64-mingw32-ranlib"
  CC="x86_64-w64-mingw32-gcc -D_WIN32_WINNT=0x0601-DTCL_UTF_MAX=6"
  CXX="x86_64-w64-mingw32-g++ -D_WIN32_WINT=0x0601 -DTCL_UTF_MAX=6"
  RC="x86_64-w64-mingw32-windres"
  NM="x86_64-w64-mingw32-nm"
  export STRIP AR RANLIB CC CXX RC NM
fi

SUBDIRS="tcl libressl zlib curl tcludp tdom tclvfs tclkit trofs tbcload tls"
SUBDIRS="${SUBDIRS} Memchan trf TclCurl sdl2tk"

  echo >&3 "done"
) || fail

echo -n "build tclwmf ... "
(
  exec 3>&1
  exec >> build.log 2>&1
  CC=`echo $CC | sed -e 's/-D_WIN32_WINNT=0x[0-9]\+//g'`
  cd tclwmf
  test -e build-stamp && echo >&3 "already done" && exit 0
  DESTDIR=${HERE} ./configure --build=x86_64-windows-mingw32 --prefix=${PFX} \
    --with-tcl=${HERE}/tcl/win --with-tk=${HERE}/sdl2tk/win \
    --enable-threads || exit 1
  make || exit 1
  make install-binaries install-libraries DESTDIR=${HERE} || exit 1