#! /bin/sh -e

# DP: update _tkinter.c to CVS HEAD (2003-05-19) for compatibility
# DP: with threaded tk8.4.

dir=
if [ $# -eq 3 -a "$2" = '-d' ]; then
    pdir="-d $3"
    dir="$3/"
elif [ $# -ne 1 ]; then
    echo >&2 "usage: `basename $0`: -patch|-unpatch [-d <srcdir>]"
    exit 1
fi
case "$1" in
    -patch)
        patch $pdir -f --no-backup-if-mismatch -p0 < $0
        #cd ${dir}gcc && autoconf
        ;;
    -unpatch)
        patch $pdir -f --no-backup-if-mismatch -R -p0 < $0
        #rm ${dir}gcc/configure
        ;;
    *)
	echo >&2 "usage: `basename $0`: -patch|-unpatch [-d <srcdir>]"
        exit 1
esac
exit 0

--- Lib/pydoc.py.old	2002-12-18 10:35:01.000000000 +0100
+++ Lib/pydoc.py	2002-12-29 13:58:09.000000000 +0100
@@ -1919,6 +1919,7 @@
             self.expanded = 0
             self.window.wm_geometry('%dx%d' % (self.minwidth, self.minheight))
             self.window.wm_minsize(self.minwidth, self.minheight)
+            self.window.tk.willdispatch()
 
             import threading
             threading.Thread(

--- Modules/_tkinter.c~	2003-02-21 14:21:30.000000000 +0100
+++ Modules/_tkinter.c	2003-05-19 22:49:21.000000000 +0200
@@ -9,17 +9,13 @@
 
 /* TCL/TK VERSION INFO:
 
-	Only Tcl/Tk 8.0 and later are supported.  Older versions are not
-	supported.  (Use Python 1.5.2 if you cannot upgrade your Tcl/Tk
+	Only Tcl/Tk 8.2 and later are supported.  Older versions are not
+	supported.  (Use Python 2.2 if you cannot upgrade your Tcl/Tk
 	libraries.)
 */
 
 /* XXX Further speed-up ideas, involving Tcl 8.0 features:
 
-   - In Tcl_Call(), create Tcl objects from the arguments, possibly using
-   intelligent mappings between Python objects and Tcl objects (e.g. ints,
-   floats and Tcl window pointers could be handled specially).
-
    - Register a new Tcl type, "Python callable", which can be called more
    efficiently and passed to Tcl_EvalObj() directly (if this is possible).
 
@@ -41,6 +37,32 @@
 #define MAC_TCL
 #endif
 
+/* Allow using this code in Python 2.[12] */
+#ifndef PyDoc_STRVAR
+#define PyDoc_STRVAR(name,str) static char name[] = str
+#endif
+
+#ifndef PyMODINIT_FUNC
+#define PyMODINIT_FUNC void
+#endif
+
+#ifndef PyBool_Check
+#define PyBool_Check(o)       0
+#define PyBool_FromLong       PyInt_FromLong
+#endif
+
+/* Starting with Tcl 8.4, many APIs offer const-correctness.  Unfortunately,
+   making _tkinter correct for this API means to break earlier
+   versions. USE_COMPAT_CONST allows to make _tkinter work with both 8.4 and
+   earlier versions. Once Tcl releases before 8.4 don't need to be supported
+   anymore, this should go. */
+#define USE_COMPAT_CONST
+
+/* If Tcl is compiled for threads, we must also define TCL_THREAD. We define
+   it always; if Tcl is not threaded, the thread functions in
+   Tcl are empty.  */
+#define TCL_THREADS
+
 #ifdef TK_FRAMEWORK
 #include <Tcl/tcl.h>
 #include <Tk/tk.h>
@@ -49,10 +71,29 @@
 #include <tk.h>
 #endif
 
+/* For Tcl 8.2 and 8.3, CONST* is not defined (except on Cygwin). */
+#ifndef CONST84_RETURN
+#define CONST84_RETURN
+#undef CONST
+#define CONST
+#endif
+
 #define TKMAJORMINOR (TK_MAJOR_VERSION*1000 + TK_MINOR_VERSION)
 
-#if TKMAJORMINOR < 8000
-#error "Tk older than 8.0 not supported"
+#if TKMAJORMINOR < 8002
+#error "Tk older than 8.2 not supported"
+#endif
+
+/* Unicode conversion assumes that Tcl_UniChar is two bytes.
+   We cannot test this directly, so we test UTF-8 size instead,
+   expecting that TCL_UTF_MAX is changed if Tcl ever supports
+   either UTF-16 or UCS-4.  
+   Redhat 8 sets TCL_UTF_MAX to 6, and uses wchar_t for 
+   Tcl_Unichar. This is also ok as long as Python uses UCS-4,
+   as well.
+*/
+#if TCL_UTF_MAX != 3 && !(defined(Py_UNICODE_WIDE) && TCL_UTF_MAX==6)
+#error "unsupported Tcl configuration"
 #endif
 
 #if defined(macintosh)
@@ -96,9 +137,8 @@
 
 #ifdef WITH_THREAD
 
-/* The threading situation is complicated.  Tcl is not thread-safe, except for
-   Tcl 8.1, which will probably remain in alpha status for another 6 months
-   (and the README says that Tk will probably remain thread-unsafe forever).
+/* The threading situation is complicated.  Tcl is not thread-safe, except
+   when configured with --enable-threads.
    So we need to use a lock around all uses of Tcl.  Previously, the Python
    interpreter lock was used for this.  However, this causes problems when
    other Python threads need to run while Tcl is blocked waiting for events.
@@ -133,31 +173,58 @@
    These locks expand to several statements and brackets; they should not be
    used in branches of if statements and the like.
 
+   If Tcl is threaded, this approach won't work anymore. The Tcl interpreter is
+   only valid in the thread that created it, and all Tk activity must happen in this
+   thread, also. That means that the mainloop must be invoked in the thread that
+   created the interpreter. Invoking commands from other threads is possible;
+   _tkinter will queue an event for the interpreter thread, which will then
+   execute the command and pass back the result. If the main thread is not in the
+   mainloop, and invoking commands causes an exception; if the main loop is running
+   but not processing events, the command invocation will block.
+
+   In addition, for a threaded Tcl, a single global tcl_tstate won't be sufficient
+   anymore, since multiple Tcl interpreters may simultaneously dispatch in different
+   threads. So we use the Tcl TLS API.
+
 */
 
 static PyThread_type_lock tcl_lock = 0;
+
+#ifdef TCL_THREADS
+static Tcl_ThreadDataKey state_key;
+typedef PyThreadState *ThreadSpecificData;
+#define tcl_tstate (*(PyThreadState**)Tcl_GetThreadData(&state_key, sizeof(PyThreadState*)))
+#else
 static PyThreadState *tcl_tstate = NULL;
+#endif
 
 #define ENTER_TCL \
 	{ PyThreadState *tstate = PyThreadState_Get(); Py_BEGIN_ALLOW_THREADS \
-	    PyThread_acquire_lock(tcl_lock, 1); tcl_tstate = tstate;
+	    if(tcl_lock)PyThread_acquire_lock(tcl_lock, 1); tcl_tstate = tstate;
 
 #define LEAVE_TCL \
-    tcl_tstate = NULL; PyThread_release_lock(tcl_lock); Py_END_ALLOW_THREADS}
+    tcl_tstate = NULL; if(tcl_lock)PyThread_release_lock(tcl_lock); Py_END_ALLOW_THREADS}
 
 #define ENTER_OVERLAP \
 	Py_END_ALLOW_THREADS
 
 #define LEAVE_OVERLAP_TCL \
-	tcl_tstate = NULL; PyThread_release_lock(tcl_lock); }
+	tcl_tstate = NULL; if(tcl_lock)PyThread_release_lock(tcl_lock); }
 
 #define ENTER_PYTHON \
 	{ PyThreadState *tstate = tcl_tstate; tcl_tstate = NULL; \
-            PyThread_release_lock(tcl_lock); PyEval_RestoreThread((tstate)); }
+	    if(tcl_lock)PyThread_release_lock(tcl_lock); PyEval_RestoreThread((tstate)); }
 
 #define LEAVE_PYTHON \
 	{ PyThreadState *tstate = PyEval_SaveThread(); \
-            PyThread_acquire_lock(tcl_lock, 1); tcl_tstate = tstate; }
+	    if(tcl_lock)PyThread_acquire_lock(tcl_lock, 1); tcl_tstate = tstate; }
+
+#define CHECK_TCL_APPARTMENT \
+	if (((TkappObject *)self)->threaded && \
+	    ((TkappObject *)self)->thread_id != Tcl_GetCurrentThread()) { \
+		PyErr_SetString(PyExc_RuntimeError, "Calling Tcl from different appartment"); \
+		return 0; \
+	}
 
 #else
 
@@ -167,6 +234,7 @@
 #define LEAVE_OVERLAP_TCL
 #define ENTER_PYTHON
 #define LEAVE_PYTHON
+#define CHECK_TCL_APPARTMENT
 
 #endif
 
@@ -186,7 +254,7 @@
 void Tcl_MacSetEventProc(TclMacConvertEventPtr procPtr);
 int TkMacConvertEvent(EventRecord *eventPtr);
 
-staticforward int PyMacConvertEvent(EventRecord *eventPtr);
+static int PyMacConvertEvent(EventRecord *eventPtr);
 
 #include <SIOUX.h>
 extern int SIOUXIsAppWindow(WindowPtr);
@@ -199,11 +267,24 @@
 
 /**** Tkapp Object Declaration ****/
 
-staticforward PyTypeObject Tkapp_Type;
+static PyTypeObject Tkapp_Type;
 
 typedef struct {
 	PyObject_HEAD
 	Tcl_Interp *interp;
+	int wantobjects;
+	int threaded; /* True if tcl_platform[threaded] */
+	Tcl_ThreadId thread_id;
+	int dispatching;
+	/* We cannot include tclInt.h, as this is internal.
+	   So we cache interesting types here. */
+	Tcl_ObjType *BooleanType;
+	Tcl_ObjType *ByteArrayType;
+	Tcl_ObjType *DoubleType;
+	Tcl_ObjType *IntType;
+	Tcl_ObjType *ListType;
+	Tcl_ObjType *ProcBodyType;
+	Tcl_ObjType *StringType;
 } TkappObject;
 
 #define Tkapp_Check(v) ((v)->ob_type == &Tkapp_Type)
@@ -237,6 +318,8 @@
 
 /**** Utils ****/
 
+static int Tkinter_busywaitinterval = 20;
+
 #ifdef WITH_THREAD
 #ifndef MS_WINDOWS
 
@@ -252,6 +335,25 @@
 	select(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &t);
 }
 #endif /* MS_WINDOWS */
+
+/* Wait up to 1s for the mainloop to come up. */
+
+static int
+WaitForMainloop(TkappObject* self)
+{
+	int i;
+	for (i = 0; i < 10; i++) {
+		if (self->dispatching)
+			return 1;
+		Py_BEGIN_ALLOW_THREADS
+		Sleep(100);
+		Py_END_ALLOW_THREADS
+	}
+	if (self->dispatching)
+		return 1;
+	PyErr_SetString(PyExc_RuntimeError, "main thread is not in main loop");
+	return 0;
+}
 #endif /* WITH_THREAD */
 
 
@@ -409,6 +511,67 @@
 	return v;
 }
 
+/* In some cases, Tcl will still return strings that are supposed to be
+   lists. SplitObj walks through a nested tuple, finding string objects that
+   need to be split. */
+
+PyObject *
+SplitObj(PyObject *arg)
+{
+	if (PyTuple_Check(arg)) {
+		int i, size;
+		PyObject *elem, *newelem, *result;
+
+		size = PyTuple_Size(arg);
+		result = NULL;
+		/* Recursively invoke SplitObj for all tuple items.
+		   If this does not return a new object, no action is
+		   needed. */
+		for(i = 0; i < size; i++) {
+			elem = PyTuple_GetItem(arg, i);
+			newelem = SplitObj(elem);
+			if (!newelem) {
+				Py_XDECREF(result);
+				return NULL;
+			}
+			if (!result) {
+				int k;
+				if (newelem == elem) {
+					Py_DECREF(newelem);
+					continue;
+				}
+				result = PyTuple_New(size);
+				if (!result)
+					return NULL;
+				for(k = 0; k < i; k++) {
+					elem = PyTuple_GetItem(arg, k);
+					Py_INCREF(elem);
+					PyTuple_SetItem(result, k, elem);
+				}
+			}
+			PyTuple_SetItem(result, i, newelem);
+		}
+		if (result)
+			return result;
+		/* Fall through, returning arg. */
+	}
+	else if (PyString_Check(arg)) {
+		int argc;
+		char **argv;
+		char *list = PyString_AsString(arg);
+
+		if (Tcl_SplitList((Tcl_Interp *)NULL, list, &argc, &argv) != TCL_OK) {
+			Py_INCREF(arg);
+			return arg;
+		}
+		Tcl_Free(FREECAST argv);
+		if (argc > 1)
+			return Split(PyString_AsString(arg));
+		/* Fall through, returning arg. */
+	}
+	Py_INCREF(arg);
+	return arg;
+}
 
 
 /**** Tkapp Object ****/
@@ -443,7 +606,8 @@
 static void DisableEventHook(void); /* Forward */
 
 static TkappObject *
-Tkapp_New(char *screenName, char *baseName, char *className, int interactive)
+Tkapp_New(char *screenName, char *baseName, char *className,
+	  int interactive, int wantobjects)
 {
 	TkappObject *v;
 	char *argv0;
@@ -453,6 +617,34 @@
 		return NULL;
 
 	v->interp = Tcl_CreateInterp();
+	v->wantobjects = wantobjects;
+	v->threaded = Tcl_GetVar2Ex(v->interp, "tcl_platform", "threaded",
+				    TCL_GLOBAL_ONLY) != NULL;
+	v->thread_id = Tcl_GetCurrentThread();
+	v->dispatching = 0;
+
+#ifndef TCL_THREADS
+	if (v->threaded) {
+	    PyErr_SetString(PyExc_RuntimeError, "Tcl is threaded but _tkinter is not");
+	    Py_DECREF(v);
+	    return 0;
+	}
+#endif
+#ifdef WITH_THREAD
+	if (v->threaded && tcl_lock) {
+	    /* If Tcl is threaded, we don't need the lock. */
+	    PyThread_free_lock(tcl_lock);
+	    tcl_lock = NULL;
+	}
+#endif
+
+	v->BooleanType = Tcl_GetObjType("boolean");
+	v->ByteArrayType = Tcl_GetObjType("bytearray");
+	v->DoubleType = Tcl_GetObjType("double");
+	v->IntType = Tcl_GetObjType("int");
+	v->ListType = Tcl_GetObjType("list");
+	v->ProcBodyType = Tcl_GetObjType("procbody");
+	v->StringType = Tcl_GetObjType("string");
 
 #if defined(macintosh)
 	/* This seems to be needed */
@@ -495,14 +687,208 @@
 }
 
 
+static void
+Tkapp_ThreadSend(TkappObject *self, Tcl_Event *ev,
+		 Tcl_Condition *cond, Tcl_Mutex *mutex)
+{
+	Py_BEGIN_ALLOW_THREADS;
+	Tcl_MutexLock(mutex);
+	Tcl_ThreadQueueEvent(self->thread_id, ev, TCL_QUEUE_TAIL);
+	Tcl_ThreadAlert(self->thread_id);
+	Tcl_ConditionWait(cond, mutex, NULL);
+	Tcl_MutexUnlock(mutex);
+	Py_END_ALLOW_THREADS
+}
+
 
 /** Tcl Eval **/
 
-#if TKMAJORMINOR >= 8001
-#define USING_OBJECTS
+typedef struct {
+	PyObject_HEAD
+	Tcl_Obj *value;
+	PyObject *string; /* This cannot cause cycles. */
+} PyTclObject;
+
+staticforward PyTypeObject PyTclObject_Type;
+#define PyTclObject_Check(v)	((v)->ob_type == &PyTclObject_Type)
+
+static PyObject *
+newPyTclObject(Tcl_Obj *arg)
+{
+	PyTclObject *self;
+	self = PyObject_New(PyTclObject, &PyTclObject_Type);
+	if (self == NULL)
+		return NULL;
+	Tcl_IncrRefCount(arg);
+	self->value = arg;
+	self->string = NULL;
+	return (PyObject*)self;
+}
+
+static void
+PyTclObject_dealloc(PyTclObject *self)
+{
+	Tcl_DecrRefCount(self->value);
+	Py_XDECREF(self->string);
+	PyObject_Del(self);
+}
+
+static PyObject *
+PyTclObject_str(PyTclObject *self)
+{
+	if (self->string && PyString_Check(self->string)) {
+		Py_INCREF(self->string);
+		return self->string;
+	}
+	/* XXX Could cache value if it is an ASCII string. */
+	return PyString_FromString(Tcl_GetString(self->value));
+}
+
+static char*
+PyTclObject_TclString(PyObject *self)
+{
+	return Tcl_GetString(((PyTclObject*)self)->value);
+}
+
+/* Like _str, but create Unicode if necessary. */
+PyDoc_STRVAR(PyTclObject_string__doc__, 
+"the string representation of this object, either as string or Unicode");
+
+static PyObject *
+PyTclObject_string(PyTclObject *self, void *ignored)
+{
+	char *s;
+	int i, len;
+	if (!self->string) {
+		s = Tcl_GetStringFromObj(self->value, &len);
+		for (i = 0; i < len; i++)
+			if (s[i] & 0x80)
+				break;
+#ifdef Py_USING_UNICODE
+		if (i == len)
+			/* It is an ASCII string. */
+			self->string = PyString_FromStringAndSize(s, len);
+		else {
+			self->string = PyUnicode_DecodeUTF8(s, len, "strict");
+			if (!self->string) {
+				PyErr_Clear();
+				self->string = PyString_FromStringAndSize(s, len);
+			}
+		}
+#else
+		self->string = PyString_FromStringAndSize(s, len);
 #endif
+		if (!self->string)
+			return NULL;
+	}
+	Py_INCREF(self->string);
+	return self->string;
+}
+
+#ifdef Py_USING_UNICODE
+PyDoc_STRVAR(PyTclObject_unicode__doc__, "convert argument to unicode");
 
-#ifdef USING_OBJECTS
+static PyObject *
+PyTclObject_unicode(PyTclObject *self, void *ignored)
+{
+	char *s;
+	int len;
+	if (self->string && PyUnicode_Check(self->string)) {
+		Py_INCREF(self->string);
+		return self->string;
+	}
+	/* XXX Could chache result if it is non-ASCII. */
+	s = Tcl_GetStringFromObj(self->value, &len);
+	return PyUnicode_DecodeUTF8(s, len, "strict");
+}
+#endif
+
+static PyObject *
+PyTclObject_repr(PyTclObject *self)
+{
+	char buf[50];
+	PyOS_snprintf(buf, 50, "<%s object at 0x%.8x>",
+		      self->value->typePtr->name, (int)self->value);
+	return PyString_FromString(buf);
+}
+
+static int
+PyTclObject_cmp(PyTclObject *self, PyTclObject *other)
+{
+	int res;
+	res = strcmp(Tcl_GetString(self->value),
+		     Tcl_GetString(other->value));
+	if (res < 0) return -1;
+	if (res > 0) return 1;
+	return 0;
+}
+
+PyDoc_STRVAR(get_typename__doc__, "name of the Tcl type");
+
+static PyObject*
+get_typename(PyTclObject* obj, void* ignored)
+{
+	return PyString_FromString(obj->value->typePtr->name);
+}
+
+
+static PyGetSetDef PyTclObject_getsetlist[] = {
+	{"typename", (getter)get_typename, NULL, get_typename__doc__},
+	{"string", (getter)PyTclObject_string, NULL, 
+	 PyTclObject_string__doc__},
+	{0},
+};
+
+static PyMethodDef PyTclObject_methods[] = {
+	{"__unicode__",	(PyCFunction)PyTclObject_unicode, METH_NOARGS,
+	PyTclObject_unicode__doc__},
+	{0}
+};
+
+statichere PyTypeObject PyTclObject_Type = {
+	PyObject_HEAD_INIT(NULL)
+	0,			/*ob_size*/
+	"_tkinter.Tcl_Obj",		/*tp_name*/
+	sizeof(PyTclObject),	/*tp_basicsize*/
+	0,			/*tp_itemsize*/
+	/* methods */
+	(destructor)PyTclObject_dealloc, /*tp_dealloc*/
+	0,			/*tp_print*/
+	0,			/*tp_getattr*/
+	0,			/*tp_setattr*/
+	(cmpfunc)PyTclObject_cmp,	/*tp_compare*/
+	(reprfunc)PyTclObject_repr,	/*tp_repr*/
+	0,			/*tp_as_number*/
+	0,			/*tp_as_sequence*/
+	0,			/*tp_as_mapping*/
+	0,			/*tp_hash*/
+        0,                      /*tp_call*/
+        (reprfunc)PyTclObject_str,        /*tp_str*/
+        PyObject_GenericGetAttr,/*tp_getattro*/
+        0,                      /*tp_setattro*/
+        0,                      /*tp_as_buffer*/
+        Py_TPFLAGS_DEFAULT,     /*tp_flags*/
+        0,                      /*tp_doc*/
+        0,                      /*tp_traverse*/
+        0,                      /*tp_clear*/
+        0,                      /*tp_richcompare*/
+        0,                      /*tp_weaklistoffset*/
+        0,                      /*tp_iter*/
+        0,                      /*tp_iternext*/
+        PyTclObject_methods,    /*tp_methods*/
+        0,			/*tp_members*/
+        PyTclObject_getsetlist, /*tp_getset*/
+        0,                      /*tp_base*/
+        0,                      /*tp_dict*/
+        0,                      /*tp_descr_get*/
+        0,                      /*tp_descr_set*/
+        0,                      /*tp_dictoffset*/
+        0,                      /*tp_init*/
+        0,                      /*tp_alloc*/
+        0,                      /*tp_new*/
+        0,                      /*tp_free*/
+        0,                      /*tp_is_gc*/
+};
 
 static Tcl_Obj*
 AsObj(PyObject *value)
@@ -512,6 +898,8 @@
 	if (PyString_Check(value))
 		return Tcl_NewStringObj(PyString_AS_STRING(value),
 					PyString_GET_SIZE(value));
+	else if (PyBool_Check(value))
+		return Tcl_NewBooleanObj(PyObject_IsTrue(value));
 	else if (PyInt_Check(value))
 		return Tcl_NewLongObj(PyInt_AS_LONG(value));
 	else if (PyFloat_Check(value))
@@ -530,28 +918,42 @@
 	}
 #ifdef Py_USING_UNICODE
 	else if (PyUnicode_Check(value)) {
-#if TKMAJORMINOR <= 8001
-		/* In Tcl 8.1 we must use UTF-8 */
-		PyObject* utf8 = PyUnicode_AsUTF8String(value);
-		if (!utf8)
-			return 0;
-		result = Tcl_NewStringObj(PyString_AS_STRING(utf8),
-					  PyString_GET_SIZE(utf8));
-		Py_DECREF(utf8);
-		return result;
-#else /* TKMAJORMINOR > 8001 */
-		/* In Tcl 8.2 and later, use Tcl_NewUnicodeObj() */
-		if (sizeof(Py_UNICODE) != sizeof(Tcl_UniChar)) {
-			/* XXX Should really test this at compile time */
-			PyErr_SetString(PyExc_SystemError,
-				"Py_UNICODE and Tcl_UniChar differ in size");
-			return 0;
+		Py_UNICODE *inbuf = PyUnicode_AS_UNICODE(value);
+		int size = PyUnicode_GET_SIZE(value);
+		/* This #ifdef assumes that Tcl uses UCS-2.
+		   See TCL_UTF_MAX test above. */
+#if defined(Py_UNICODE_WIDE) && TCL_UTF_MAX == 3
+		Tcl_UniChar *outbuf;
+		int i;
+		outbuf = (Tcl_UniChar*)ckalloc(size * sizeof(Tcl_UniChar));
+		if (!outbuf) {
+			PyErr_NoMemory();
+			return NULL;
+		}
+		for (i = 0; i < size; i++) {
+			if (inbuf[i] >= 0x10000) {
+				/* Tcl doesn't do UTF-16, yet. */
+				PyErr_SetString(PyExc_ValueError,
+						"unsupported character");
+				ckfree(FREECAST outbuf);
+				return NULL;
+			}
+			outbuf[i] = inbuf[i];
 		}
-		return Tcl_NewUnicodeObj(PyUnicode_AS_UNICODE(value),
-					 PyUnicode_GET_SIZE(value));
-#endif /* TKMAJORMINOR > 8001 */
+		result = Tcl_NewUnicodeObj(outbuf, size);
+		ckfree(FREECAST outbuf);
+		return result;
+#else
+		return Tcl_NewUnicodeObj(inbuf, size);
+#endif
+
 	}
 #endif
+	else if(PyTclObject_Check(value)) {
+		Tcl_Obj *v = ((PyTclObject*)value)->value;
+		Tcl_IncrRefCount(v);
+		return v;
+	} 
 	else {
 		PyObject *v = PyObject_Str(value);
 		if (!v)
@@ -562,19 +964,157 @@
 	}
 }
 
-static PyObject *
-Tkapp_Call(PyObject *self, PyObject *args)
+static PyObject*
+FromObj(PyObject* tkapp, Tcl_Obj *value)
 {
-	Tcl_Obj *objStore[ARGSZ];
-	Tcl_Obj **objv = NULL;
-	int objc = 0, i;
-	PyObject *res = NULL;
-	Tcl_Interp *interp = Tkapp_Interp(self);
-	/* Could add TCL_EVAL_GLOBAL if wrapped by GlobalCall... */
-	int flags = TCL_EVAL_DIRECT;
+	PyObject *result = NULL;
+	TkappObject *app = (TkappObject*)tkapp;
+
+	if (value->typePtr == NULL) {
+		/* If the result contains any bytes with the top bit set,
+		   it's UTF-8 and we should decode it to Unicode */
+#ifdef Py_USING_UNICODE
+		int i;
+		char *s = value->bytes;
+		int len = value->length;
+		for (i = 0; i < len; i++) {
+			if (value->bytes[i] & 0x80)
+				break;
+		}
 
-	objv = objStore;
+		if (i == value->length)
+			result = PyString_FromStringAndSize(s, len);
+		else {
+			/* Convert UTF-8 to Unicode string */
+			result = PyUnicode_DecodeUTF8(s, len, "strict");
+			if (result == NULL) {
+				PyErr_Clear();
+				result = PyString_FromStringAndSize(s, len);
+			}
+		}
+#else
+		res = PyString_FromStringAndSize(value->bytes, value->length);
+#endif
+		return result;
+	}
+
+	if (value->typePtr == app->BooleanType) {
+		result = value->internalRep.longValue ? Py_True : Py_False;
+		Py_INCREF(result);
+		return result;
+	}
+
+	if (value->typePtr == app->ByteArrayType) {
+		int size;
+		char *data = (char*)Tcl_GetByteArrayFromObj(value, &size);
+		return PyString_FromStringAndSize(data, size);
+	}
+
+	if (value->typePtr == app->DoubleType) {
+		return PyFloat_FromDouble(value->internalRep.doubleValue);
+	}
+
+	if (value->typePtr == app->IntType) {
+		return PyInt_FromLong(value->internalRep.longValue);
+	}
 
+	if (value->typePtr == app->ListType) {
+		int size;
+		int i, status;
+		PyObject *elem;
+		Tcl_Obj *tcl_elem;
+
+		status = Tcl_ListObjLength(Tkapp_Interp(tkapp), value, &size);
+		if (status == TCL_ERROR)
+			return Tkinter_Error(tkapp);
+		result = PyTuple_New(size);
+		if (!result)
+			return NULL;
+		for (i = 0; i < size; i++) {
+			status = Tcl_ListObjIndex(Tkapp_Interp(tkapp),
+						  value, i, &tcl_elem);
+			if (status == TCL_ERROR) {
+				Py_DECREF(result);
+				return Tkinter_Error(tkapp);
+			}
+			elem = FromObj(tkapp, tcl_elem);
+			if (!elem) {
+				Py_DECREF(result);
+				return NULL;
+			}
+			PyTuple_SetItem(result, i, elem);
+		}
+		return result;
+	}
+
+	if (value->typePtr == app->ProcBodyType) {
+	  /* fall through: return tcl object. */
+	}
+
+	if (value->typePtr == app->StringType) {
+#ifdef Py_USING_UNICODE
+#if defined(Py_UNICODE_WIDE) && TCL_UTF_MAX==3
+		PyObject *result;
+		int size;
+		Tcl_UniChar *input;
+		Py_UNICODE *output;
+
+		size = Tcl_GetCharLength(value);
+		result = PyUnicode_FromUnicode(NULL, size);
+		if (!result)
+			return NULL;
+		input = Tcl_GetUnicode(value);
+		output = PyUnicode_AS_UNICODE(result);
+		while (size--)
+			*output++ = *input++;
+		return result;
+#else
+		return PyUnicode_FromUnicode(Tcl_GetUnicode(value),
+					     Tcl_GetCharLength(value));
+#endif
+#else
+		int size;
+		char *c;
+		c = Tcl_GetStringFromObj(value, &size);
+		return PyString_FromStringAndSize(c, size);
+#endif
+	}
+
+	return newPyTclObject(value);
+}
+
+/* This mutex synchronizes inter-thread command calls. */
+
+TCL_DECLARE_MUTEX(call_mutex)
+
+typedef struct Tkapp_CallEvent {
+	Tcl_Event ev;	     /* Must be first */
+	TkappObject *self;
+	PyObject *args;
+	int flags;
+	PyObject **res;
+	PyObject **exc_type, **exc_value, **exc_tb;
+	Tcl_Condition done;
+} Tkapp_CallEvent;
+
+void
+Tkapp_CallDeallocArgs(Tcl_Obj** objv, Tcl_Obj** objStore, int objc)
+{
+	int i;
+	for (i = 0; i < objc; i++)
+		Tcl_DecrRefCount(objv[i]);
+	if (objv != objStore)
+		ckfree(FREECAST objv);
+}
+
+/* Convert Python objects to Tcl objects. This must happen in the
+   interpreter thread, which may or may not be the calling thread. */
+
+static Tcl_Obj**
+Tkapp_CallArgs(PyObject *args, Tcl_Obj** objStore, int *pobjc)
+{
+	Tcl_Obj **objv = objStore;
+	int objc = 0, i;
 	if (args == NULL)
 		/* do nothing */;
 
@@ -613,19 +1153,30 @@
 			Tcl_IncrRefCount(objv[i]);
 		}
 	}
+	*pobjc = objc;
+	return objv;
+finally:
+	Tkapp_CallDeallocArgs(objv, objStore, objc);
+	return NULL;
+}
 
-	ENTER_TCL
-
-	i = Tcl_EvalObjv(interp, objc, objv, flags);
+/* Convert the results of a command call into a Python objects. */
 
-	ENTER_OVERLAP
-	if (i == TCL_ERROR)
-		Tkinter_Error(self);
-	else {
-		/* We could request the object result here, but doing
-		   so would confuse applications that expect a string. */
-		char *s = Tcl_GetStringResult(interp);
-		char *p = s;
+static PyObject*
+Tkapp_CallResult(TkappObject *self)
+{
+	PyObject *res = NULL;
+	if(self->wantobjects) {
+		Tcl_Obj *value = Tcl_GetObjResult(self->interp);
+		/* Not sure whether the IncrRef is necessary, but something
+		   may overwrite the interpreter result while we are
+		   converting it. */
+		Tcl_IncrRefCount(value);
+		res = FromObj((PyObject*)self, value);
+		Tcl_DecrRefCount(value);
+	} else {
+		const char *s = Tcl_GetStringResult(self->interp);
+		const char *p = s;
 
 		/* If the result contains any bytes with the top bit set,
 		   it's UTF-8 and we should decode it to Unicode */
@@ -652,135 +1203,127 @@
 		res = PyString_FromStringAndSize(s, (int)(p-s));
 #endif
 	}
-
-	LEAVE_OVERLAP_TCL
-
-  finally:
-	for (i = 0; i < objc; i++)
-		Tcl_DecrRefCount(objv[i]);
-	if (objv != objStore)
-		ckfree(FREECAST objv);
 	return res;
 }
 
-#else /* !USING_OBJECTS */
+/* Tkapp_CallProc is the event procedure that is executed in the context of
+   the Tcl interpreter thread. Initially, it holds the Tcl lock, and doesn't
+   hold the Python lock. */
 
-static PyObject *
-Tkapp_Call(PyObject *self, PyObject *args)
+static int
+Tkapp_CallProc(Tkapp_CallEvent *e, int flags)
 {
-	/* This is copied from Merge() */
-	PyObject *tmp = NULL;
-	char *argvStore[ARGSZ];
-	char **argv = NULL;
-	int fvStore[ARGSZ];
-	int *fv = NULL;
-	int argc = 0, fvc = 0, i;
-	PyObject *res = NULL; /* except this has a different type */
-	Tcl_CmdInfo info; /* and this is added */
-	Tcl_Interp *interp = Tkapp_Interp(self); /* and this too */
-
-	if (!(tmp = PyList_New(0)))
-	    return NULL;
-
-	argv = argvStore;
-	fv = fvStore;
-
-	if (args == NULL)
-		argc = 0;
-
-	else if (!PyTuple_Check(args)) {
-		argc = 1;
-		fv[0] = 0;
-		if (!(argv[0] = AsString(args, tmp)))
-			goto finally;
-	}
-	else {
-		argc = PyTuple_Size(args);
-
-		if (argc > ARGSZ) {
-			argv = (char **)ckalloc(argc * sizeof(char *));
-			fv = (int *)ckalloc(argc * sizeof(int));
-			if (argv == NULL || fv == NULL) {
-				PyErr_NoMemory();
-				goto finally;
-			}
-		}
-
-		for (i = 0; i < argc; i++) {
-			PyObject *v = PyTuple_GetItem(args, i);
-			if (PyTuple_Check(v)) {
-				fv[i] = 1;
-				if (!(argv[i] = Merge(v)))
-					goto finally;
-				fvc++;
+	Tcl_Obj *objStore[ARGSZ];
+	Tcl_Obj **objv;
+	int objc;
+	int i;
+	ENTER_PYTHON
+	objv = Tkapp_CallArgs(e->args, objStore, &objc);
+	if (!objv) {
+		PyErr_Fetch(e->exc_type, e->exc_value, e->exc_tb);
+		*(e->res) = NULL;
 			}
-			else if (v == Py_None) {
-				argc = i;
-				break;
+	LEAVE_PYTHON
+	if (!objv)
+		goto done;
+	i = Tcl_EvalObjv(e->self->interp, objc, objv, e->flags);
+	ENTER_PYTHON
+	if (i == TCL_ERROR) {
+		*(e->res) = NULL;
+		*(e->exc_type) = NULL;
+		*(e->exc_tb) = NULL;
+		*(e->exc_value) = PyObject_CallFunction(
+			Tkinter_TclError, "s",
+			Tcl_GetStringResult(e->self->interp));
 			}
 			else {
-				fv[i] = 0;
-				if (!(argv[i] = AsString(v, tmp)))
-					goto finally;
-				fvc++;
+		*(e->res) = Tkapp_CallResult(e->self);
 			}
+	LEAVE_PYTHON
+  done:
+	/* Wake up calling thread. */
+	Tcl_MutexLock(&call_mutex);
+	Tcl_ConditionNotify(&e->done);
+	Tcl_MutexUnlock(&call_mutex);
+	return 1;
+}
+
+/* This is the main entry point for calling a Tcl command.
+   It supports three cases, with regard to threading:
+   1. Tcl is not threaded: Must have the Tcl lock, then can invoke command in
+      the context of the calling thread.
+   2. Tcl is threaded, caller of the command is in the interpreter thread:
+      Execute the command in the calling thread. Since the Tcl lock will
+      not be used, we can merge that with case 1.
+   3. Tcl is threaded, caller is in a different thread: Must queue an event to
+      the interpreter thread. Allocation of Tcl objects needs to occur in the
+      interpreter thread, so we ship the PyObject* args to the target thread,
+      and perform processing there. */
+
+static PyObject *
+Tkapp_Call(PyObject *_self, PyObject *args)
+{
+	Tcl_Obj *objStore[ARGSZ];
+	Tcl_Obj **objv = NULL;
+	int objc, i;
+	PyObject *res = NULL;
+	TkappObject *self = (TkappObject*)_self;
+	/* Could add TCL_EVAL_GLOBAL if wrapped by GlobalCall... */
+	int flags = TCL_EVAL_DIRECT;
+
+#ifdef WITH_THREAD
+	if (self->threaded && self->thread_id != Tcl_GetCurrentThread()) {
+		/* We cannot call the command directly. Instead, we must
+		   marshal the parameters to the interpreter thread. */
+		Tkapp_CallEvent *ev;
+		PyObject *exc_type, *exc_value, *exc_tb;
+		if (!WaitForMainloop(self))
+			return NULL;
+		ev = (Tkapp_CallEvent*)ckalloc(sizeof(Tkapp_CallEvent));
+		ev->ev.proc = (Tcl_EventProc*)Tkapp_CallProc;
+		ev->self = self;
+		ev->args = args;
+		ev->res = &res;
+		ev->exc_type = &exc_type;
+		ev->exc_value = &exc_value;
+		ev->exc_tb = &exc_tb;
+		ev->done = (Tcl_Condition)0;
+
+		Tkapp_ThreadSend(self, (Tcl_Event*)ev, &ev->done, &call_mutex);
+
+		if (res == NULL) {
+			if (exc_type)
+				PyErr_Restore(exc_type, exc_value, exc_tb);
+			else
+				PyErr_SetObject(Tkinter_TclError, exc_value);
 		}
 	}
-	/* End code copied from Merge() */
+	else 
+#endif
+	{
+
+		objv = Tkapp_CallArgs(args, objStore, &objc);
+		if (!objv)
+			return NULL;
 
-	/* All this to avoid a call to Tcl_Merge() and the corresponding call
-	   to Tcl_SplitList() inside Tcl_Eval()...  It can save a bundle! */
-	if (Py_VerboseFlag >= 2) {
-		for (i = 0; i < argc; i++)
-			PySys_WriteStderr("%s ", argv[i]);
-	}
 	ENTER_TCL
-	info.proc = NULL;
-	if (argc < 1 ||
-	    !Tcl_GetCommandInfo(interp, argv[0], &info) ||
-	    info.proc == NULL)
-	{
-		char *cmd;
-		cmd = Tcl_Merge(argc, argv);
-		i = Tcl_Eval(interp, cmd);
-		ckfree(cmd);
-	}
-	else {
-		Tcl_ResetResult(interp);
-		i = (*info.proc)(info.clientData, interp, argc, argv);
-	}
+
+		i = Tcl_EvalObjv(self->interp, objc, objv, flags);
+
 	ENTER_OVERLAP
-	if (info.proc == NULL && Py_VerboseFlag >= 2)
-		PySys_WriteStderr("... use TclEval ");
-	if (i == TCL_ERROR) {
-		if (Py_VerboseFlag >= 2)
-			PySys_WriteStderr("... error: '%s'\n",
-				Tcl_GetStringResult(interp));
-		Tkinter_Error(self);
-	}
-	else {
-		if (Py_VerboseFlag >= 2)
-			PySys_WriteStderr("-> '%s'\n", Tcl_GetStringResult(interp));
-		res = PyString_FromString(Tcl_GetStringResult(interp));
-	}
+
+		if (i == TCL_ERROR)
+			Tkinter_Error(_self);
+		else
+			res = Tkapp_CallResult(self);
+
 	LEAVE_OVERLAP_TCL
 
-	/* Copied from Merge() again */
-  finally:
-	for (i = 0; i < fvc; i++)
-		if (fv[i]) {
-			ckfree(argv[i]);
+		Tkapp_CallDeallocArgs(objv, objStore, objc);
 		}
-	if (argv != argvStore)
-		ckfree(FREECAST argv);
-	if (fv != fvStore)
-		ckfree(FREECAST fv);
-
-	Py_DECREF(tmp);
 	return res;
 }
 
-#endif /* !USING_OBJECTS */
 
 static PyObject *
 Tkapp_GlobalCall(PyObject *self, PyObject *args)
@@ -794,6 +1337,8 @@
 	char *cmd;
 	PyObject *res = NULL;
 
+	CHECK_TCL_APPARTMENT;
+
 	cmd  = Merge(args);
 	if (cmd) {
 		int err;
@@ -821,6 +1366,8 @@
 	if (!PyArg_ParseTuple(args, "s:eval", &script))
 		return NULL;
 
+	CHECK_TCL_APPARTMENT;
+
 	ENTER_TCL
 	err = Tcl_Eval(Tkapp_Interp(self), script);
 	ENTER_OVERLAP
@@ -842,6 +1389,8 @@
 	if (!PyArg_ParseTuple(args, "s:globaleval", &script))
 		return NULL;
 
+	CHECK_TCL_APPARTMENT;
+
 	ENTER_TCL
 	err = Tcl_GlobalEval(Tkapp_Interp(self), script);
 	ENTER_OVERLAP
@@ -863,6 +1412,8 @@
 	if (!PyArg_ParseTuple(args, "s:evalfile", &fileName))
 		return NULL;
 
+	CHECK_TCL_APPARTMENT;
+
 	ENTER_TCL
 	err = Tcl_EvalFile(Tkapp_Interp(self), fileName);
 	ENTER_OVERLAP
@@ -885,6 +1436,8 @@
 	if (!PyArg_ParseTuple(args, "s", &script))
 		return NULL;
 
+	CHECK_TCL_APPARTMENT;
+
 	ENTER_TCL
 	err = Tcl_RecordAndEval(Tkapp_Interp(self), script, TCL_NO_EVAL);
 	ENTER_OVERLAP
@@ -903,6 +1456,8 @@
 
 	if (!PyArg_ParseTuple(args, "s:adderrorinfo", &msg))
 		return NULL;
+	CHECK_TCL_APPARTMENT;
+
 	ENTER_TCL
 	Tcl_AddErrorInfo(Tkapp_Interp(self), msg);
 	LEAVE_TCL
@@ -915,62 +1470,165 @@
 
 /** Tcl Variable **/
 
+TCL_DECLARE_MUTEX(var_mutex)
+
+typedef PyObject* (*EventFunc)(PyObject*, PyObject *args, int flags);
+typedef struct VarEvent {
+	Tcl_Event ev; /* must be first */
+	PyObject *self;
+	PyObject *args;
+	int flags;
+	EventFunc func;
+	PyObject **res;
+	PyObject **exc_type;
+	PyObject **exc_val;
+	Tcl_Condition cond;
+} VarEvent;
+
+static int
+varname_converter(PyObject *in, void *_out)
+{
+	char **out = (char**)_out;
+	if (PyString_Check(in)) {
+		*out = PyString_AsString(in);
+		return 1;
+	}
+	if (PyTclObject_Check(in)) {
+		*out = PyTclObject_TclString(in);
+		return 1;
+	}
+	/* XXX: Should give diagnostics. */
+	return 0;
+}	
+
+void
+var_perform(VarEvent *ev)
+{
+	*(ev->res) = ev->func(ev->self, ev->args, ev->flags);
+	if (!*(ev->res)) {
+		PyObject *exc, *val, *tb;
+		PyErr_Fetch(&exc, &val, &tb);
+		PyErr_NormalizeException(&exc, &val, &tb);
+		*(ev->exc_type) = exc;
+		*(ev->exc_val) = val;
+		Py_DECREF(tb);
+	}
+		
+}
+
+static int
+var_proc(VarEvent* ev, int flags)
+{
+	ENTER_PYTHON
+        var_perform(ev);
+	Tcl_MutexLock(&var_mutex);
+	Tcl_ConditionNotify(&ev->cond);
+	Tcl_MutexUnlock(&var_mutex);
+	LEAVE_PYTHON
+	return 1;
+}
+
+static PyObject*
+var_invoke(EventFunc func, PyObject *_self, PyObject *args, int flags)
+{
+	TkappObject *self = (TkappObject*)_self;
+#ifdef WITH_THREAD
+	if (self->threaded && self->thread_id != Tcl_GetCurrentThread()) {
+		TkappObject *self = (TkappObject*)_self;
+		VarEvent *ev;
+		PyObject *res, *exc_type, *exc_val;
+		
+		/* The current thread is not the interpreter thread.  Marshal
+		   the call to the interpreter thread, then wait for
+		   completion. */
+		if (!WaitForMainloop(self))
+			return NULL;
+
+		ev = (VarEvent*)ckalloc(sizeof(VarEvent));
+
+		ev->self = _self;
+		ev->args = args;
+		ev->flags = flags;
+		ev->func = func;
+		ev->res = &res;
+		ev->exc_type = &exc_type;
+		ev->exc_val = &exc_val;
+		ev->cond = NULL;
+		ev->ev.proc = (Tcl_EventProc*)var_proc;
+		Tkapp_ThreadSend(self, (Tcl_Event*)ev, &ev->cond, &var_mutex);
+		if (!res) {
+			PyErr_SetObject(exc_type, exc_val);
+			Py_DECREF(exc_type);
+			Py_DECREF(exc_val);
+			return NULL;
+		}
+		return res;
+	}
+#endif
+        /* Tcl is not threaded, or this is the interpreter thread. */
+	return func(_self, args, flags);
+}
+
 static PyObject *
 SetVar(PyObject *self, PyObject *args, int flags)
 {
-	char *name1, *name2, *ok, *s;
+	char *name1, *name2;
 	PyObject *newValue;
-	PyObject *tmp;
-
-	tmp = PyList_New(0);
-	if (!tmp)
-		return NULL;
+	PyObject *res = NULL;
+	Tcl_Obj *newval, *ok;
 
-	if (PyArg_ParseTuple(args, "sO:setvar", &name1, &newValue)) {
-		/* XXX Merge? */
-		s = AsString(newValue, tmp);
-		if (s == NULL)
+	if (PyArg_ParseTuple(args, "O&O:setvar", 
+			     varname_converter, &name1, &newValue)) {
+		/* XXX Acquire tcl lock??? */
+		newval = AsObj(newValue);
+		if (newval == NULL)
 			return NULL;
 		ENTER_TCL
-		ok = Tcl_SetVar(Tkapp_Interp(self), name1, s, flags);
-		LEAVE_TCL
+		ok = Tcl_SetVar2Ex(Tkapp_Interp(self), name1, NULL, 
+				   newval, flags);
+		ENTER_OVERLAP
+		if (!ok)
+			Tkinter_Error(self);
+		else {
+			res = Py_None;
+			Py_INCREF(res);
+		}
+		LEAVE_OVERLAP_TCL
 	}
 	else {
 		PyErr_Clear();
 		if (PyArg_ParseTuple(args, "ssO:setvar",
 				     &name1, &name2, &newValue)) {
-			s = AsString(newValue, tmp);
-			if (s == NULL)
-				return NULL;
+			/* XXX must hold tcl lock already??? */
+			newval = AsObj(newValue);
 			ENTER_TCL
-			ok = Tcl_SetVar2(Tkapp_Interp(self), name1, name2, 
-					 s, flags);
-			LEAVE_TCL
+			ok = Tcl_SetVar2Ex(Tkapp_Interp(self), name1, name2, newval, flags);
+			ENTER_OVERLAP
+			if (!ok)
+				Tkinter_Error(self);
+			else {
+				res = Py_None;
+				Py_INCREF(res);
+			}
+			LEAVE_OVERLAP_TCL
 		}
 		else {
-			Py_DECREF(tmp);
 			return NULL;
 		}
 	}
-	Py_DECREF(tmp);
-
-	if (!ok)
-		return Tkinter_Error(self);
-
-	Py_INCREF(Py_None);
-	return Py_None;
+	return res;
 }
 
 static PyObject *
 Tkapp_SetVar(PyObject *self, PyObject *args)
 {
-	return SetVar(self, args, TCL_LEAVE_ERR_MSG);
+	return var_invoke(SetVar, self, args, TCL_LEAVE_ERR_MSG);
 }
 
 static PyObject *
 Tkapp_GlobalSetVar(PyObject *self, PyObject *args)
 {
-	return SetVar(self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
+	return var_invoke(SetVar, self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
 }
 
 
@@ -978,23 +1636,23 @@
 static PyObject *
 GetVar(PyObject *self, PyObject *args, int flags)
 {
-	char *name1, *name2=NULL, *s;
+	char *name1, *name2=NULL;
 	PyObject *res = NULL;
+	Tcl_Obj *tres;
 
-	if (!PyArg_ParseTuple(args, "s|s:getvar", &name1, &name2))
+	if (!PyArg_ParseTuple(args, "O&|s:getvar", 
+			      varname_converter, &name1, &name2))
 		return NULL;
-	ENTER_TCL
-	if (name2 == NULL)
-		s = Tcl_GetVar(Tkapp_Interp(self), name1, flags);
 
-	else
-		s = Tcl_GetVar2(Tkapp_Interp(self), name1, name2, flags);
+	ENTER_TCL
+	tres = Tcl_GetVar2Ex(Tkapp_Interp(self), name1, name2, flags);
 	ENTER_OVERLAP
-
-	if (s == NULL)
-		res = Tkinter_Error(self);
-	else
-		res = PyString_FromString(s);
+	if (((TkappObject*)self)->wantobjects) {
+		res = FromObj(self, tres);
+	}
+	else {
+		res = PyString_FromString(Tcl_GetString(tres));
+	}
 	LEAVE_OVERLAP_TCL
 	return res;
 }
@@ -1002,13 +1660,13 @@
 static PyObject *
 Tkapp_GetVar(PyObject *self, PyObject *args)
 {
-	return GetVar(self, args, TCL_LEAVE_ERR_MSG);
+	return var_invoke(GetVar, self, args, TCL_LEAVE_ERR_MSG);
 }
 
 static PyObject *
 Tkapp_GlobalGetVar(PyObject *self, PyObject *args)
 {
-	return GetVar(self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
+	return var_invoke(GetVar, self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
 }
 
 
@@ -1017,19 +1675,15 @@
 UnsetVar(PyObject *self, PyObject *args, int flags)
 {
 	char *name1, *name2=NULL;
-	PyObject *res = NULL;
 	int code;
+	PyObject *res = NULL;
 
 	if (!PyArg_ParseTuple(args, "s|s:unsetvar", &name1, &name2))
 		return NULL;
-	ENTER_TCL
-	if (name2 == NULL)
-		code = Tcl_UnsetVar(Tkapp_Interp(self), name1, flags);
 
-	else
+	ENTER_TCL
 		code = Tcl_UnsetVar2(Tkapp_Interp(self), name1, name2, flags);
 	ENTER_OVERLAP
-
 	if (code == TCL_ERROR)
 		res = Tkinter_Error(self);
 	else {
@@ -1043,13 +1697,13 @@
 static PyObject *
 Tkapp_UnsetVar(PyObject *self, PyObject *args)
 {
-	return UnsetVar(self, args, TCL_LEAVE_ERR_MSG);
+	return var_invoke(UnsetVar, self, args, TCL_LEAVE_ERR_MSG);
 }
 
 static PyObject *
 Tkapp_GlobalUnsetVar(PyObject *self, PyObject *args)
 {
-	return UnsetVar(self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
+	return var_invoke(UnsetVar, self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
 }
 
 
@@ -1062,6 +1716,13 @@
 	char *s;
 	int v;
 
+	if (PyTuple_Size(args) == 1) {
+		PyObject* o = PyTuple_GetItem(args, 0);
+		if (PyInt_Check(o)) {
+			Py_INCREF(o);
+			return o;
+		}
+	}
 	if (!PyArg_ParseTuple(args, "s:getint", &s))
 		return NULL;
 	if (Tcl_GetInt(Tkapp_Interp(self), s, &v) == TCL_ERROR)
@@ -1075,6 +1736,13 @@
 	char *s;
 	double v;
 
+	if (PyTuple_Size(args) == 1) {
+		PyObject *o = PyTuple_GetItem(args, 0);
+		if (PyFloat_Check(o)) {
+			Py_INCREF(o);
+			return o;
+		}
+	}
 	if (!PyArg_ParseTuple(args, "s:getdouble", &s))
 		return NULL;
 	if (Tcl_GetDouble(Tkapp_Interp(self), s, &v) == TCL_ERROR)
@@ -1088,11 +1756,18 @@
 	char *s;
 	int v;
 
+	if (PyTuple_Size(args) == 1) {
+		PyObject *o = PyTuple_GetItem(args, 0);
+		if (PyInt_Check(o)) {
+			Py_INCREF(o);
+			return o;
+		}
+	}
 	if (!PyArg_ParseTuple(args, "s:getboolean", &s))
 		return NULL;
 	if (Tcl_GetBoolean(Tkapp_Interp(self), s, &v) == TCL_ERROR)
 		return Tkinter_Error(self);
-	return Py_BuildValue("i", v);
+	return PyBool_FromLong(v);
 }
 
 static PyObject *
@@ -1104,6 +1779,9 @@
 
 	if (!PyArg_ParseTuple(args, "s:exprstring", &s))
 		return NULL;
+	
+	CHECK_TCL_APPARTMENT;
+
 	ENTER_TCL
 	retval = Tcl_ExprString(Tkapp_Interp(self), s);
 	ENTER_OVERLAP
@@ -1125,6 +1803,9 @@
 
 	if (!PyArg_ParseTuple(args, "s:exprlong", &s))
 		return NULL;
+
+	CHECK_TCL_APPARTMENT;
+
 	ENTER_TCL
 	retval = Tcl_ExprLong(Tkapp_Interp(self), s, &v);
 	ENTER_OVERLAP
@@ -1146,6 +1827,7 @@
 
 	if (!PyArg_ParseTuple(args, "s:exprdouble", &s))
 		return NULL;
+	CHECK_TCL_APPARTMENT;
 	PyFPE_START_PROTECT("Tkapp_ExprDouble", return 0)
 	ENTER_TCL
 	retval = Tcl_ExprDouble(Tkapp_Interp(self), s, &v);
@@ -1169,6 +1851,7 @@
 
 	if (!PyArg_ParseTuple(args, "s:exprboolean", &s))
 		return NULL;
+	CHECK_TCL_APPARTMENT;
 	ENTER_TCL
 	retval = Tcl_ExprBoolean(Tkapp_Interp(self), s, &v);
 	ENTER_OVERLAP
@@ -1191,6 +1874,13 @@
 	PyObject *v;
 	int i;
 
+	if (PyTuple_Size(args) == 1) {
+		v = PyTuple_GetItem(args, 0);
+		if (PyTuple_Check(v)) {
+			Py_INCREF(v);
+			return v;
+		}
+	}
 	if (!PyArg_ParseTuple(args, "et:splitlist", "utf-8", &list))
 		return NULL;
 
@@ -1219,6 +1909,13 @@
 {
 	char *list;
 
+	if (PyTuple_Size(args) == 1) {
+		PyObject* o = PyTuple_GetItem(args, 0);
+		if (PyTuple_Check(o)) {
+			o = SplitObj(o);
+			return o;
+		}
+	}
 	if (!PyArg_ParseTuple(args, "et:split", "utf-8", &list))
 		return NULL;
 	return Split(list);
@@ -1329,13 +2026,42 @@
 
 
 
+
+TCL_DECLARE_MUTEX(command_mutex)
+
+typedef struct CommandEvent{
+	Tcl_Event ev;
+	Tcl_Interp* interp;
+	char *name;
+	int create;
+	int *status;
+	ClientData *data;
+	Tcl_Condition done;
+} CommandEvent;
+
+static int
+Tkapp_CommandProc(CommandEvent *ev, int flags)
+{
+	if (ev->create)
+		*ev->status = Tcl_CreateCommand(
+			ev->interp, ev->name, PythonCmd,
+			ev->data, PythonCmdDelete) == NULL;
+	else
+		*ev->status = Tcl_DeleteCommand(ev->interp, ev->name);
+	Tcl_MutexLock(&command_mutex);
+	Tcl_ConditionNotify(&ev->done);
+	Tcl_MutexUnlock(&command_mutex);
+	return 1;
+}
+
 static PyObject *
-Tkapp_CreateCommand(PyObject *self, PyObject *args)
+Tkapp_CreateCommand(PyObject *_self, PyObject *args)
 {
+	TkappObject *self = (TkappObject*)_self;
 	PythonCmd_ClientData *data;
 	char *cmdName;
 	PyObject *func;
-	Tcl_Command err;
+	int err;
 
 	if (!PyArg_ParseTuple(args, "sO:createcommand", &cmdName, &func))
 		return NULL;
@@ -1344,19 +2070,39 @@
 		return NULL;
 	}
 
+#ifdef WITH_THREAD
+	if (self->threaded && self->thread_id != Tcl_GetCurrentThread() &&
+	    !WaitForMainloop(self))
+		return NULL;
+#endif
+
 	data = PyMem_NEW(PythonCmd_ClientData, 1);
 	if (!data)
 		return PyErr_NoMemory();
 	Py_XINCREF(self);
 	Py_XINCREF(func);
-	data->self = self;
+	data->self = _self;
 	data->func = func;
 
+	if (self->threaded && self->thread_id != Tcl_GetCurrentThread()) {
+		CommandEvent *ev = (CommandEvent*)ckalloc(sizeof(CommandEvent));
+		ev->ev.proc = (Tcl_EventProc*)Tkapp_CommandProc;
+		ev->interp = self->interp;
+		ev->create = 1;
+		ev->name = cmdName;
+		ev->data = (ClientData)data;
+		ev->status = &err;
+		ev->done = NULL;
+		Tkapp_ThreadSend(self, (Tcl_Event*)ev, &ev->done, &command_mutex);
+	}
+	else {
 	ENTER_TCL
-	err = Tcl_CreateCommand(Tkapp_Interp(self), cmdName, PythonCmd,
-				(ClientData)data, PythonCmdDelete);
+		err = Tcl_CreateCommand(
+			Tkapp_Interp(self), cmdName, PythonCmd,
+			(ClientData)data, PythonCmdDelete) == NULL;
 	LEAVE_TCL
-	if (err == NULL) {
+	}
+	if (err) {
 		PyErr_SetString(Tkinter_TclError, "can't create Tcl command");
 		PyMem_DEL(data);
 		return NULL;
@@ -1369,16 +2115,31 @@
 
 
 static PyObject *
-Tkapp_DeleteCommand(PyObject *self, PyObject *args)
+Tkapp_DeleteCommand(PyObject *_self, PyObject *args)
 {
+	TkappObject *self = (TkappObject*)_self;
 	char *cmdName;
 	int err;
 
 	if (!PyArg_ParseTuple(args, "s:deletecommand", &cmdName))
 		return NULL;
+	if (self->threaded && self->thread_id != Tcl_GetCurrentThread()) {
+		CommandEvent *ev;
+		ev = (CommandEvent*)ckalloc(sizeof(CommandEvent));
+		ev->ev.proc = (Tcl_EventProc*)Tkapp_CommandProc;
+		ev->interp = self->interp;
+		ev->create = 0;
+		ev->name = cmdName;
+		ev->status = &err;
+		ev->done = NULL;
+		Tkapp_ThreadSend(self, (Tcl_Event*)ev, &ev->done, 
+				 &command_mutex);
+	}
+	else {
 	ENTER_TCL
-	err = Tcl_DeleteCommand(Tkapp_Interp(self), cmdName);
+		err = Tcl_DeleteCommand(self->interp, cmdName);
 	LEAVE_TCL
+	}
 	if (err == -1) {
 		PyErr_SetString(Tkinter_TclError, "can't delete Tcl command");
 		return NULL;
@@ -1469,6 +2230,21 @@
 	if (!PyArg_ParseTuple(args, "OiO:createfilehandler",
 			      &file, &mask, &func))
 		return NULL;
+
+#ifdef WITH_THREAD
+	if (!self && !tcl_lock) {
+		/* We don't have the Tcl lock since Tcl is threaded. */
+		PyErr_SetString(PyExc_RuntimeError,
+				"_tkinter.createfilehandler not supported "
+				"for threaded Tcl");
+		return NULL;
+	}
+#endif
+
+	if (self) {
+		CHECK_TCL_APPARTMENT;
+	}
+
 	tfile = PyObject_AsFileDescriptor(file);
 	if (tfile < 0)
 		return NULL;
@@ -1497,6 +2273,21 @@
   
 	if (!PyArg_ParseTuple(args, "O:deletefilehandler", &file))
 		return NULL;
+
+#ifdef WITH_THREAD
+	if (!self && !tcl_lock) {
+		/* We don't have the Tcl lock since Tcl is threaded. */
+		PyErr_SetString(PyExc_RuntimeError,
+				"_tkinter.deletefilehandler not supported "
+				"for threaded Tcl");
+		return NULL;
+	}
+#endif
+
+	if (self) {
+		CHECK_TCL_APPARTMENT;
+	}
+
 	tfile = PyObject_AsFileDescriptor(file);
 	if (tfile < 0)
 		return NULL;
@@ -1515,7 +2306,7 @@
 
 /**** Tktt Object (timer token) ****/
 
-staticforward PyTypeObject Tktt_Type;
+static PyTypeObject Tktt_Type;
 
 typedef struct {
 	PyObject_HEAD
@@ -1546,7 +2337,7 @@
 
 static PyMethodDef Tktt_methods[] =
 {
-	{"deletetimerhandler", Tktt_DeleteTimerHandler, 1},
+	{"deletetimerhandler", Tktt_DeleteTimerHandler, METH_VARARGS},
 	{NULL, NULL}
 };
 
@@ -1661,6 +2452,21 @@
 		PyErr_SetString(PyExc_TypeError, "bad argument list");
 		return NULL;
 	}
+
+#ifdef WITH_THREAD
+	if (!self && !tcl_lock) {
+		/* We don't have the Tcl lock since Tcl is threaded. */
+		PyErr_SetString(PyExc_RuntimeError,
+				"_tkinter.createtimerhandler not supported "
+				"for threaded Tcl");
+		return NULL;
+	}
+#endif
+
+	if (self) {
+		CHECK_TCL_APPARTMENT;
+	}
+
 	v = Tktt_New(func);
 	v->token = Tcl_CreateTimerHandler(milliseconds, TimerHandler,
 					  (ClientData)v);
@@ -1672,9 +2478,10 @@
 /** Event Loop **/
 
 static PyObject *
-Tkapp_MainLoop(PyObject *self, PyObject *args)
+Tkapp_MainLoop(PyObject *_self, PyObject *args)
 {
 	int threshold = 0;
+	TkappObject *self = (TkappObject*)_self;
 #ifdef WITH_THREAD
 	PyThreadState *tstate = PyThreadState_Get();
 #endif
@@ -1682,6 +2489,21 @@
 	if (!PyArg_ParseTuple(args, "|i:mainloop", &threshold))
 		return NULL;
 
+#ifdef WITH_THREAD
+	if (!self && !tcl_lock) {
+		/* We don't have the Tcl lock since Tcl is threaded. */
+		PyErr_SetString(PyExc_RuntimeError,
+				"_tkinter.mainloop not supported "
+				"for threaded Tcl");
+		return NULL;
+	}
+#endif
+
+	if (self) {
+		CHECK_TCL_APPARTMENT;
+		self->dispatching = 1;
+	}
+
 	quitMainLoop = 0;
 	while (Tk_GetNumMainWindows() > threshold &&
 	       !quitMainLoop &&
@@ -1690,24 +2512,37 @@
 		int result;
 
 #ifdef WITH_THREAD
+		if (self && self->threaded) {
+			/* Allow other Python threads to run. */
+			ENTER_TCL
+			result = Tcl_DoOneEvent(0);
+			LEAVE_TCL
+		}
+		else {
 		Py_BEGIN_ALLOW_THREADS
-		PyThread_acquire_lock(tcl_lock, 1);
+			if(tcl_lock)PyThread_acquire_lock(tcl_lock, 1);
 		tcl_tstate = tstate;
 		result = Tcl_DoOneEvent(TCL_DONT_WAIT);
 		tcl_tstate = NULL;
-		PyThread_release_lock(tcl_lock);
+			if(tcl_lock)PyThread_release_lock(tcl_lock);
 		if (result == 0)
-			Sleep(20);
+				Sleep(Tkinter_busywaitinterval);
 		Py_END_ALLOW_THREADS
+		}
 #else
 		result = Tcl_DoOneEvent(0);
 #endif
 
-		if (PyErr_CheckSignals() != 0)
+		if (PyErr_CheckSignals() != 0) {
+			if (self)
+				self->dispatching = 0;
 			return NULL;
+		}
 		if (result < 0)
 			break;
 	}
+	if (self)
+		self->dispatching = 0;
 	quitMainLoop = 0;
 
 	if (errorInCmd) {
@@ -1758,45 +2593,70 @@
 }
 
 
+static PyObject *
+Tkapp_WantObjects(PyObject *self, PyObject *args)
+{
+
+	int wantobjects;
+	if (!PyArg_ParseTuple(args, "i:wantobjects", &wantobjects))
+		return NULL;
+	((TkappObject*)self)->wantobjects = wantobjects;
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *
+Tkapp_WillDispatch(PyObject *self, PyObject *args)
+{
+
+	((TkappObject*)self)->dispatching = 1;
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
 
 /**** Tkapp Method List ****/
 
 static PyMethodDef Tkapp_methods[] =
 {
-	{"call", 	       Tkapp_Call, 0},
-	{"globalcall", 	       Tkapp_GlobalCall, 0},
-	{"eval", 	       Tkapp_Eval, 1},
-	{"globaleval", 	       Tkapp_GlobalEval, 1},
-	{"evalfile", 	       Tkapp_EvalFile, 1},
-	{"record", 	       Tkapp_Record, 1},
-	{"adderrorinfo",       Tkapp_AddErrorInfo, 1},
-	{"setvar", 	       Tkapp_SetVar, 1},
-	{"globalsetvar",       Tkapp_GlobalSetVar, 1},
-	{"getvar", 	       Tkapp_GetVar, 1},
-	{"globalgetvar",       Tkapp_GlobalGetVar, 1},
-	{"unsetvar", 	       Tkapp_UnsetVar, 1},
-	{"globalunsetvar",     Tkapp_GlobalUnsetVar, 1},
-	{"getint", 	       Tkapp_GetInt, 1},
-	{"getdouble", 	       Tkapp_GetDouble, 1},
-	{"getboolean", 	       Tkapp_GetBoolean, 1},
-	{"exprstring", 	       Tkapp_ExprString, 1},
-	{"exprlong", 	       Tkapp_ExprLong, 1},
-	{"exprdouble", 	       Tkapp_ExprDouble, 1},
-	{"exprboolean",        Tkapp_ExprBoolean, 1},
-	{"splitlist", 	       Tkapp_SplitList, 1},
-	{"split", 	       Tkapp_Split, 1},
-	{"merge", 	       Tkapp_Merge, 0},
-	{"createcommand",      Tkapp_CreateCommand, 1},
-	{"deletecommand",      Tkapp_DeleteCommand, 1},
+	{"willdispatch",       Tkapp_WillDispatch, METH_NOARGS},
+	{"wantobjects",	       Tkapp_WantObjects, METH_VARARGS},
+	{"call", 	       Tkapp_Call, METH_OLDARGS},
+	{"globalcall", 	       Tkapp_GlobalCall, METH_OLDARGS},
+	{"eval", 	       Tkapp_Eval, METH_VARARGS},
+	{"globaleval", 	       Tkapp_GlobalEval, METH_VARARGS},
+	{"evalfile", 	       Tkapp_EvalFile, METH_VARARGS},
+	{"record", 	       Tkapp_Record, METH_VARARGS},
+	{"adderrorinfo",       Tkapp_AddErrorInfo, METH_VARARGS},
+	{"setvar", 	       Tkapp_SetVar, METH_VARARGS},
+	{"globalsetvar",       Tkapp_GlobalSetVar, METH_VARARGS},
+	{"getvar", 	       Tkapp_GetVar, METH_VARARGS},
+	{"globalgetvar",       Tkapp_GlobalGetVar, METH_VARARGS},
+	{"unsetvar", 	       Tkapp_UnsetVar, METH_VARARGS},
+	{"globalunsetvar",     Tkapp_GlobalUnsetVar, METH_VARARGS},
+	{"getint", 	       Tkapp_GetInt, METH_VARARGS},
+	{"getdouble", 	       Tkapp_GetDouble, METH_VARARGS},
+	{"getboolean", 	       Tkapp_GetBoolean, METH_VARARGS},
+	{"exprstring", 	       Tkapp_ExprString, METH_VARARGS},
+	{"exprlong", 	       Tkapp_ExprLong, METH_VARARGS},
+	{"exprdouble", 	       Tkapp_ExprDouble, METH_VARARGS},
+	{"exprboolean",        Tkapp_ExprBoolean, METH_VARARGS},
+	{"splitlist", 	       Tkapp_SplitList, METH_VARARGS},
+	{"split", 	       Tkapp_Split, METH_VARARGS},
+	{"merge", 	       Tkapp_Merge, METH_OLDARGS},
+	{"createcommand",      Tkapp_CreateCommand, METH_VARARGS},
+	{"deletecommand",      Tkapp_DeleteCommand, METH_VARARGS},
 #ifdef HAVE_CREATEFILEHANDLER
-	{"createfilehandler",  Tkapp_CreateFileHandler, 1},
-	{"deletefilehandler",  Tkapp_DeleteFileHandler, 1},
+	{"createfilehandler",  Tkapp_CreateFileHandler, METH_VARARGS},
+	{"deletefilehandler",  Tkapp_DeleteFileHandler, METH_VARARGS},
 #endif
-	{"createtimerhandler", Tkapp_CreateTimerHandler, 1},
-	{"mainloop", 	       Tkapp_MainLoop, 1},
-	{"dooneevent", 	       Tkapp_DoOneEvent, 1},
-	{"quit", 	       Tkapp_Quit, 1},
-	{"interpaddr",         Tkapp_InterpAddr, 1},
+	{"createtimerhandler", Tkapp_CreateTimerHandler, METH_VARARGS},
+	{"mainloop", 	       Tkapp_MainLoop, METH_VARARGS},
+	{"dooneevent", 	       Tkapp_DoOneEvent, METH_VARARGS},
+	{"quit", 	       Tkapp_Quit, METH_VARARGS},
+	{"interpaddr",         Tkapp_InterpAddr, METH_VARARGS},
 	{NULL, 		       NULL}
 };
 
@@ -1807,6 +2667,7 @@
 static void
 Tkapp_Dealloc(PyObject *self)
 {
+	/*CHECK_TCL_APPARTMENT;*/
 	ENTER_TCL
 	Tcl_DeleteInterp(Tkapp_Interp(self));
 	LEAVE_TCL
@@ -1959,6 +2820,7 @@
 	char *baseName = NULL;
 	char *className = NULL;
 	int interactive = 0;
+	int wantobjects = 0;
 
 	baseName = strrchr(Py_GetProgramName(), '/');
 	if (baseName != NULL)
@@ -1967,27 +2829,67 @@
 		baseName = Py_GetProgramName();
 	className = "Tk";
   
-	if (!PyArg_ParseTuple(args, "|zssi:create",
+	if (!PyArg_ParseTuple(args, "|zssii:create",
 			      &screenName, &baseName, &className,
-			      &interactive))
+			      &interactive, &wantobjects))
 		return NULL;
 
 	return (PyObject *) Tkapp_New(screenName, baseName, className, 
-				      interactive);
+				      interactive, wantobjects);
+}
+
+static PyObject *
+Tkinter_setbusywaitinterval(PyObject *self, PyObject *args)
+{
+	int new_val;
+	if (!PyArg_ParseTuple(args, "i:setbusywaitinterval", &new_val))
+		return NULL;
+	if (new_val < 0) {
+		PyErr_SetString(PyExc_ValueError,
+				"busywaitinterval must be >= 0");
+		return NULL;
+	}
+	Tkinter_busywaitinterval = new_val;
+	Py_INCREF(Py_None);
+	return Py_None;
 }
 
+static char setbusywaitinterval_doc[] =
+"setbusywaitinterval(n) -> None\n\
+\n\
+Set the busy-wait interval in milliseconds between successive\n\
+calls to Tcl_DoOneEvent in a threaded Python interpreter.\n\
+It should be set to a divisor of the maximum time between\n\
+frames in an animation.";
+
+static PyObject *
+Tkinter_getbusywaitinterval(PyObject *self, PyObject *args)
+{
+        return PyInt_FromLong(Tkinter_busywaitinterval);
+}
+
+static char getbusywaitinterval_doc[] =
+"getbusywaitinterval() -> int\n\
+\n\
+Return the current busy-wait interval between successive\n\
+calls to Tcl_DoOneEvent in a threaded Python interpreter.";
+
 static PyMethodDef moduleMethods[] =
 {
-	{"_flatten",           Tkinter_Flatten, 1},
-	{"create",             Tkinter_Create, 1},
+	{"_flatten",           Tkinter_Flatten, METH_VARARGS},
+	{"create",             Tkinter_Create, METH_VARARGS},
 #ifdef HAVE_CREATEFILEHANDLER
-	{"createfilehandler",  Tkapp_CreateFileHandler, 1},
-	{"deletefilehandler",  Tkapp_DeleteFileHandler, 1},
+	{"createfilehandler",  Tkapp_CreateFileHandler, METH_VARARGS},
+	{"deletefilehandler",  Tkapp_DeleteFileHandler, METH_VARARGS},
 #endif
-	{"createtimerhandler", Tkapp_CreateTimerHandler, 1},
-	{"mainloop",           Tkapp_MainLoop, 1},
-	{"dooneevent",         Tkapp_DoOneEvent, 1},
-	{"quit",               Tkapp_Quit, 1},
+	{"createtimerhandler", Tkapp_CreateTimerHandler, METH_VARARGS},
+	{"mainloop",           Tkapp_MainLoop, METH_VARARGS},
+	{"dooneevent",         Tkapp_DoOneEvent, METH_VARARGS},
+	{"quit",               Tkapp_Quit, METH_VARARGS},
+	{"setbusywaitinterval",Tkinter_setbusywaitinterval, METH_VARARGS,
+	                       setbusywaitinterval_doc},
+	{"getbusywaitinterval",(PyCFunction)Tkinter_getbusywaitinterval,
+	                       METH_NOARGS, getbusywaitinterval_doc},
 	{NULL,                 NULL}
 };
 
@@ -2003,7 +2905,9 @@
 }
 #endif
 
+#ifdef WITH_THREAD
 static PyThreadState *event_tstate = NULL;
+#endif
 
 static int
 EventHook(void)
@@ -2030,15 +2934,15 @@
 #endif
 #if defined(WITH_THREAD) || defined(MS_WINDOWS)
 		Py_BEGIN_ALLOW_THREADS
-		PyThread_acquire_lock(tcl_lock, 1);
+		if(tcl_lock)PyThread_acquire_lock(tcl_lock, 1);
 		tcl_tstate = event_tstate;
 
 		result = Tcl_DoOneEvent(TCL_DONT_WAIT);
 
 		tcl_tstate = NULL;
-		PyThread_release_lock(tcl_lock);
+		if(tcl_lock)PyThread_release_lock(tcl_lock);
 		if (result == 0)
-			Sleep(20);
+			Sleep(Tkinter_busywaitinterval);
 		Py_END_ALLOW_THREADS
 #else
 		result = Tcl_DoOneEvent(0);
@@ -2109,7 +3013,7 @@
 }
 
 
-DL_EXPORT(void)
+PyMODINIT_FUNC
 init_tkinter(void)
 {
 	PyObject *m, *d;
@@ -2123,7 +3027,7 @@
 	m = Py_InitModule("_tkinter", moduleMethods);
 
 	d = PyModule_GetDict(m);
-	Tkinter_TclError = Py_BuildValue("s", "TclError");
+	Tkinter_TclError = PyErr_NewException("_tkinter.TclError", NULL, NULL);
 	PyDict_SetItemString(d, "TclError", Tkinter_TclError);
 
 	ins_long(d, "READABLE", TCL_READABLE);
@@ -2143,6 +3047,8 @@
 	Tktt_Type.ob_type = &PyType_Type;
 	PyDict_SetItemString(d, "TkttType", (PyObject *)&Tktt_Type);
 
+	PyTclObject_Type.ob_type = &PyType_Type;
+	PyDict_SetItemString(d, "Tcl_Obj", (PyObject *)&PyTclObject_Type);
 
 #ifdef TK_AQUA
 	/* Tk_MacOSXSetupTkNotifier must be called before Tcl's subsystems