Initial revision
diff --git a/Modules/_tkinter.c b/Modules/_tkinter.c
new file mode 100644
index 0000000..2bb7060
--- /dev/null
+++ b/Modules/_tkinter.c
@@ -0,0 +1,1056 @@
+/* tkintermodule.c -- Interface to libtk.a and libtcl.a.
+ Copyright (C) 1994 Steen Lumholt */
+
+#if 0
+#include <Py/Python.h>
+#else
+
+#include "allobjects.h"
+#include "pythonrun.h"
+#include "intrcheck.h"
+#include "modsupport.h"
+#include "sysmodule.h"
+
+#define PyObject object
+typedef struct methodlist PyMethodDef;
+#define PyInit_tkinter inittkinter
+
+#undef Py_True
+#define Py_True ((object *) &TrueObject)
+#undef True
+
+#undef Py_False
+#define Py_False ((object *) &FalseObject)
+#undef False
+
+#undef Py_None
+#define Py_None (&NoObject)
+#undef None
+
+#endif /* 0 */
+
+#include <tcl.h>
+#include <tk.h>
+
+extern char *getprogramname ();
+extern int tk_NumMainWindows;
+
+/**** Tkapp Object Declaration ****/
+
+staticforward PyTypeObject Tkapp_Type;
+
+typedef struct
+ {
+ PyObject_HEAD
+ Tcl_Interp *interp;
+ Tk_Window tkwin;
+ }
+TkappObject;
+
+#define Tkapp_Check(v) ((v)->ob_type == &Tkapp_Type)
+#define Tkapp_Tkwin(v) (((TkappObject *) (v))->tkwin)
+#define Tkapp_Interp(v) (((TkappObject *) (v))->interp)
+#define Tkapp_Result(v) (((TkappObject *) (v))->interp->result)
+
+#define DEBUG_REFCNT(v) (printf ("DEBUG: id=%p, refcnt=%i\n", \
+ (void *) v, ((PyObject *) v)->ob_refcnt))
+
+/**** Error Handling ****/
+
+static PyObject *Tkinter_TclError;
+static int errorInCmd = 0;
+static PyObject *excInCmd;
+static PyObject *valInCmd;
+
+static PyObject *
+Tkinter_Error (v)
+ PyObject *v;
+{
+ if (Tkapp_Check (v))
+ PyErr_BadInternalCall ();
+ PyErr_SetString (Tkinter_TclError, Tkapp_Result (v));
+ return NULL;
+}
+
+int
+PythonCmd_Error (interp)
+ Tcl_Interp *interp;
+{
+ errorInCmd = 1;
+ PyErr_GetAndClear (&excInCmd, &valInCmd);
+ return TCL_ERROR;
+}
+
+/**** Utils ****/
+
+static char *
+AsString (value, tmp)
+ PyObject *value;
+ PyObject *tmp;
+{
+ if (PyString_Check (value))
+ return PyString_AsString (value);
+ else
+ {
+ PyObject *v;
+
+ v = strobject (value);
+ PyList_Append (tmp, v);
+ Py_DECREF (v);
+ return PyString_AsString (v);
+ }
+}
+
+#define ARGSZ 64
+
+static char *
+Merge (args)
+ PyObject *args;
+{
+ PyObject *tmp;
+ char *argvStore[ARGSZ];
+ char **argv;
+ int fvStore[ARGSZ];
+ int *fv;
+ int argc;
+ char *res;
+ int i;
+
+ tmp = PyList_New (0);
+ argv = argvStore;
+ fv = fvStore;
+
+ if (!PyTuple_Check (args))
+ {
+ argc = 1;
+ fv[0] = 0;
+ argv[0] = AsString (args, tmp);
+ }
+ else
+ {
+ PyObject *v;
+
+ if (PyTuple_Size (args) > ARGSZ)
+ {
+ argv = malloc (PyTuple_Size (args) * sizeof (char *));
+ fv = malloc (PyTuple_Size (args) * sizeof (int));
+ if (argv == NULL || fv == NULL)
+ PyErr_NoMemory ();
+ }
+
+ argc = PyTuple_Size (args);
+ for (i = 0; i < argc; i++)
+ {
+ v = PyTuple_GetItem (args, i);
+ if (PyTuple_Check (v))
+ {
+ fv[i] = 1;
+ argv[i] = Merge (v);
+ }
+ else if (v == Py_None)
+ {
+ argc = i;
+ break;
+ }
+ else
+ {
+ fv[i] = 0;
+ argv[i] = AsString (v, tmp);
+ }
+ }
+ }
+
+ res = Tcl_Merge (argc, argv);
+
+ Py_DECREF (tmp);
+ for (i = 0; i < argc; i++)
+ if (fv[i]) free (argv[i]);
+ if (argv != argvStore)
+ free (argv);
+ if (fv != fvStore)
+ free (fv);
+
+ return res;
+}
+
+static PyObject *
+Split (self, list)
+ PyObject *self;
+ char *list;
+{
+ int argc;
+ char **argv;
+ PyObject *v;
+
+ if (list == NULL)
+ {
+ Py_INCREF (Py_None);
+ return Py_None;
+ }
+
+ if (Tcl_SplitList (Tkapp_Interp (self), list, &argc, &argv) == TCL_ERROR)
+ return Tkinter_Error (self);
+
+ if (argc == 0)
+ v = PyString_FromString ("");
+ else if (argc == 1)
+ v = PyString_FromString (argv[0]);
+ else
+ {
+ int i;
+
+ v = PyTuple_New (argc);
+ for (i = 0; i < argc; i++)
+ PyTuple_SetItem (v, i, Split (self, argv[i]));
+ }
+
+ free (argv);
+ return v;
+}
+
+/**** Tkapp Object ****/
+
+#ifndef WITH_APPINIT
+int
+Tcl_AppInit (interp)
+ Tcl_Interp *interp;
+{
+ if (Tcl_Init (interp) == TCL_ERROR)
+ return TCL_ERROR;
+ if (Tk_Init (interp) == TCL_ERROR)
+ return TCL_ERROR;
+ return TCL_OK;
+}
+#endif /* !WITH_APPINIT */
+
+/* Initialize the Tk application; see the `main' function in
+ `tkMain.c'. */
+static TkappObject *
+Tkapp_New (screenName, baseName, className, interactive)
+ char *screenName;
+ char *baseName;
+ char *className;
+ int interactive;
+{
+ TkappObject *v;
+
+ v = PyObject_NEW (TkappObject, &Tkapp_Type);
+ if (v == NULL)
+ return NULL;
+
+ v->interp = Tcl_CreateInterp ();
+ v->tkwin = Tk_CreateMainWindow (v->interp, screenName,
+ baseName, className);
+ if (v->tkwin == NULL)
+ return (TkappObject *) Tkinter_Error ((PyObject *) v);
+
+ Tk_GeometryRequest (v->tkwin, 200, 200);
+
+ if (screenName != NULL)
+ Tcl_SetVar2 (v->interp, "env", "DISPLAY", screenName, TCL_GLOBAL_ONLY);
+
+ if (interactive)
+ Tcl_SetVar (v->interp, "tcl_interactive", "1", TCL_GLOBAL_ONLY);
+ else
+ Tcl_SetVar (v->interp, "tcl_interactive", "0", TCL_GLOBAL_ONLY);
+
+#ifndef WITH_APPINIT
+ if (Tcl_AppInit (v->interp) != TCL_OK)
+ {
+ PyErr_SetString (Tkinter_TclError, "Tcl_AppInit failed"); /* XXX */
+ return NULL;
+ }
+#endif /* !WITH_APPINIT */
+
+ return v;
+}
+
+/** Tcl Eval **/
+
+static PyObject *
+Tkapp_Call (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *cmd;
+
+ cmd = Merge (args);
+ if (Tcl_Eval (Tkapp_Interp (self), cmd) == TCL_ERROR)
+ {
+ free (cmd);
+ return Tkinter_Error (self);
+ }
+
+ free (cmd);
+ return PyString_FromString (Tkapp_Result (self));
+}
+
+static PyObject *
+Tkapp_GlobalCall (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *cmd;
+
+ cmd = Merge (args);
+ if (Tcl_GlobalEval (Tkapp_Interp (self), cmd) == TCL_ERROR)
+ {
+ free (cmd);
+ return Tkinter_Error (self);
+ }
+
+ free (cmd);
+ return PyString_FromString (Tkapp_Result (self));
+}
+
+static PyObject *
+Tkapp_Eval (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *script;
+
+ if (!PyArg_Parse (args, "s", &script))
+ return NULL;
+
+ if (Tcl_Eval (Tkapp_Interp (self), script) == TCL_ERROR)
+ return Tkinter_Error (self);
+
+ return PyString_FromString (Tkapp_Result (self));
+}
+
+static PyObject *
+Tkapp_GlobalEval (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *script;
+
+ if (!PyArg_Parse (args, "s", &script))
+ return NULL;
+
+ if (Tcl_GlobalEval (Tkapp_Interp (self), script) == TCL_ERROR)
+ return Tkinter_Error (self);
+
+ return PyString_FromString (Tkapp_Result (self));
+}
+
+static PyObject *
+Tkapp_EvalFile (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *fileName;
+
+ if (!PyArg_Parse (args, "s", &fileName))
+ return NULL;
+
+ if (Tcl_EvalFile (Tkapp_Interp (self), fileName) == TCL_ERROR)
+ return Tkinter_Error (self);
+
+ return PyString_FromString (Tkapp_Result (self));
+}
+
+static PyObject *
+Tkapp_Record (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *script;
+
+ if (!PyArg_Parse (args, "s", &script))
+ return NULL;
+
+ if (Tcl_RecordAndEval (Tkapp_Interp (self),
+ script, TCL_NO_EVAL) == TCL_ERROR)
+ return Tkinter_Error (self);
+
+ return PyString_FromString (Tkapp_Result (self));
+}
+
+static PyObject *
+Tkapp_AddErrorInfo (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *msg;
+
+ if (!PyArg_Parse (args, "s", &msg))
+ return NULL;
+ Tcl_AddErrorInfo (Tkapp_Interp (self), msg);
+
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/** Tcl Variable **/
+
+static PyObject *
+SetVar (self, args, flags)
+ PyObject *self;
+ PyObject *args;
+ int flags;
+{
+ char *name1, *name2, *ok;
+ PyObject *newValue;
+ PyObject *tmp;
+
+ tmp = PyList_New (0);
+
+ if (PyArg_Parse (args, "(sO)", &name1, &newValue))
+ ok = Tcl_SetVar (Tkapp_Interp (self), name1,
+ AsString (newValue, tmp), flags); /* XXX Merge? */
+ else if (PyArg_Parse (args, "(ssO)", &name1, &name2, &newValue))
+ ok = Tcl_SetVar2 (Tkapp_Interp (self), name1, name2,
+ AsString (newValue, tmp), flags);
+ else
+ {
+ Py_DECREF (tmp);
+ return NULL;
+ }
+ Py_DECREF (tmp);
+
+ if (!ok)
+ return Tkinter_Error (self);
+
+ Py_INCREF (Py_None);
+ return Py_None;
+}
+
+static PyObject *
+Tkapp_SetVar (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ return SetVar (self, args, TCL_LEAVE_ERR_MSG);
+}
+
+static PyObject *
+Tkapp_GlobalSetVar (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ return SetVar (self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
+}
+
+static PyObject *
+GetVar (self, args, flags)
+ PyObject *self;
+ PyObject *args;
+ int flags;
+{
+ char *name1, *name2, *s;
+
+ if (PyArg_Parse (args, "s", &name1))
+ s = Tcl_GetVar (Tkapp_Interp (self), name1, flags);
+ else if (PyArg_Parse (args, "(ss)", &name1, &name2))
+ s = Tcl_GetVar2 (Tkapp_Interp (self), name1, name2, flags);
+ else
+ return NULL;
+
+ if (s == NULL)
+ return Tkinter_Error (self);
+
+ return PyString_FromString (s);
+}
+
+static PyObject *
+Tkapp_GetVar (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ return GetVar (self, args, TCL_LEAVE_ERR_MSG);
+}
+
+static PyObject *
+Tkapp_GlobalGetVar (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ return GetVar (self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
+}
+
+static PyObject *
+UnsetVar (self, args, flags)
+ PyObject *self;
+ PyObject *args;
+ int flags;
+{
+ char *name1, *name2;
+ int code;
+
+ if (PyArg_Parse (args, "s", &name1))
+ code = Tcl_UnsetVar (Tkapp_Interp (self), name1, flags);
+ else if (PyArg_Parse (args, "(ss)", &name1, &name2))
+ code = Tcl_UnsetVar2 (Tkapp_Interp (self), name1, name2, flags);
+ else
+ return NULL;
+
+ if (code == TCL_ERROR)
+ return Tkinter_Error (self);
+
+ Py_INCREF (Py_None);
+ return Py_None;
+}
+
+static PyObject *
+Tkapp_UnsetVar (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ return UnsetVar (self, args, TCL_LEAVE_ERR_MSG);
+}
+
+static PyObject *
+Tkapp_GlobalUnsetVar (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ return UnsetVar (self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
+}
+
+/** Tcl to Python **/
+
+static PyObject *
+Tkapp_GetInt (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *s;
+ int v;
+
+ if (!PyArg_Parse (args, "s", &s))
+ return NULL;
+ if (Tcl_GetInt (Tkapp_Interp (self), s, &v) == TCL_ERROR)
+ return Tkinter_Error (self);
+ return Py_BuildValue ("i", v);
+}
+
+static PyObject *
+Tkapp_GetDouble (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *s;
+ double v;
+
+ if (!PyArg_Parse (args, "s", &s))
+ return NULL;
+ if (Tcl_GetDouble (Tkapp_Interp (self), s, &v) == TCL_ERROR)
+ return Tkinter_Error (self);
+ return Py_BuildValue ("d", v);
+}
+
+static PyObject *
+Tkapp_GetBoolean (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *s;
+ int v;
+
+ if (!PyArg_Parse (args, "s", &s))
+ return NULL;
+ if (Tcl_GetBoolean (Tkapp_Interp (self), s, &v) == TCL_ERROR)
+ return Tkinter_Error (self);
+ return Py_BuildValue ("i", v);
+}
+
+static PyObject *
+Tkapp_ExprString (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *s;
+
+ if (!PyArg_Parse (args, "s", &s))
+ return NULL;
+ if (Tcl_ExprString (Tkapp_Interp (self), s) == TCL_ERROR)
+ return Tkinter_Error (self);
+ return Py_BuildValue ("s", Tkapp_Result (self));
+}
+
+static PyObject *
+Tkapp_ExprLong (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *s;
+ long v;
+
+ if (!PyArg_Parse (args, "s", &s))
+ return NULL;
+ if (Tcl_ExprLong (Tkapp_Interp (self), s, &v) == TCL_ERROR)
+ return Tkinter_Error (self);
+ return Py_BuildValue ("l", v);
+}
+
+static PyObject *
+Tkapp_ExprDouble (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *s;
+ double v;
+
+ if (!PyArg_Parse (args, "s", &s))
+ return NULL;
+ if (Tcl_ExprDouble (Tkapp_Interp (self), s, &v) == TCL_ERROR)
+ return Tkinter_Error (self);
+ return Py_BuildValue ("d", v);
+}
+
+static PyObject *
+Tkapp_ExprBoolean (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *s;
+ int v;
+
+ if (!PyArg_Parse (args, "s", &s))
+ return NULL;
+ if (Tcl_ExprBoolean (Tkapp_Interp (self), s, &v) == TCL_ERROR)
+ return Tkinter_Error (self);
+ return Py_BuildValue ("i", v);
+}
+
+static PyObject *
+Tkapp_SplitList (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *list;
+ int argc;
+ char **argv;
+ PyObject *v;
+ int i;
+
+ if (!PyArg_Parse (args, "s", &list))
+ return NULL;
+
+ if (Tcl_SplitList (Tkapp_Interp (self), list, &argc, &argv) == TCL_ERROR)
+ return Tkinter_Error (self);
+
+ v = PyTuple_New (argc);
+ for (i = 0; i < argc; i++)
+ PyTuple_SetItem (v, i, PyString_FromString (argv[i]));
+
+ free (argv);
+ return v;
+}
+
+static PyObject *
+Tkapp_Split (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *list;
+
+ if (!PyArg_Parse (args, "s", &list))
+ return NULL;
+ return Split (self, list);
+}
+
+static PyObject *
+Tkapp_Merge (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *s;
+ PyObject *v;
+
+ s = Merge (args);
+ v = PyString_FromString (s);
+ free (s);
+ return v;
+}
+
+/** Tcl Command **/
+
+/* This is the Tcl command that acts as a wrapper for Python
+ function or method. */
+static int
+PythonCmd (clientData, interp, argc, argv)
+ ClientData clientData; /* Is (self, func) */
+ Tcl_Interp *interp;
+ int argc;
+ char *argv[];
+{
+ PyObject *self, *func, *arg, *res, *tmp;
+ int i;
+
+ self = PyTuple_GetItem ((PyObject *) clientData, 0);
+ func = PyTuple_GetItem ((PyObject *) clientData, 1);
+
+ /* Create argument list (argv1, ..., argvN) */
+ arg = PyTuple_New (argc - 1);
+ for (i = 0; i < (argc - 1); i++)
+ PyTuple_SetItem (arg, i, PyString_FromString (argv[i + 1]));
+
+ res = PyEval_CallObject (func, arg);
+ Py_DECREF (arg);
+ if (res == NULL)
+ return PythonCmd_Error (interp);
+
+ tmp = PyList_New (0);
+ Tcl_SetResult (Tkapp_Interp (self), AsString (res, tmp), TCL_VOLATILE);
+ Py_DECREF (res);
+ Py_DECREF (tmp);
+
+ return TCL_OK;
+}
+
+static void
+PythonCmdDelete (clientData)
+ ClientData clientData; /* Is (self, func) */
+{
+ Py_DECREF ((PyObject *) clientData);
+}
+
+static PyObject *
+Tkapp_CreateCommand (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *cmdName;
+ PyObject *data;
+ PyObject *func;
+
+ /* Args is: (cmdName, func) */
+ if (!PyTuple_Check (args)
+ || !(PyTuple_Size (args) == 2)
+ || !PyString_Check (PyTuple_GetItem (args, 0))
+ || !(PyMethod_Check (PyTuple_GetItem (args, 1))
+ || PyFunction_Check (PyTuple_GetItem (args, 1))))
+ {
+ PyErr_SetString (PyExc_TypeError, "bad argument list");
+ return NULL;
+ }
+
+ cmdName = PyString_AsString (PyTuple_GetItem (args, 0));
+ func = PyTuple_GetItem (args, 1);
+
+ data = PyTuple_New (2); /* ClientData is: (self, func) */
+
+ Py_INCREF (self);
+ PyTuple_SetItem (data, 0, self);
+
+ Py_INCREF (func);
+ PyTuple_SetItem (data, 1, func);
+
+ Tcl_CreateCommand (Tkapp_Interp (self), cmdName, PythonCmd,
+ (ClientData) data, PythonCmdDelete);
+
+ Py_INCREF (Py_None);
+ return Py_None;
+}
+
+static PyObject *
+Tkapp_DeleteCommand (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *cmdName;
+
+ if (!PyArg_Parse (args, "s", &cmdName))
+ return NULL;
+ if (Tcl_DeleteCommand (Tkapp_Interp (self), cmdName) == -1)
+ {
+ PyErr_SetString (Tkinter_TclError, "can't delete Tcl command");
+ return NULL;
+ }
+ Py_INCREF (Py_None);
+ return Py_None;
+}
+
+/** File Handler **/
+
+void
+FileHandler (clientData, mask)
+ ClientData clientData; /* Is: func */
+ int mask;
+{
+ PyObject *func;
+ PyObject *arg, *res;
+
+ func = (PyObject *) clientData;
+
+ arg = PyInt_FromLong ((long) mask);
+ res = PyEval_CallObject (func, arg);
+ Py_DECREF (arg);
+ if (res == NULL)
+ {
+ errorInCmd = 1;
+ PyErr_GetAndClear (&excInCmd, &valInCmd);
+ }
+}
+
+static PyObject *
+Tkapp_CreateFileHandler (self, args)
+ PyObject *self;
+ PyObject *args; /* Is (file, mask, func) */
+{
+ PyObject *file;
+ int mask;
+ PyObject *func;
+ int id;
+
+ if (!PyArg_Parse (args, "(OiO)", &file, &mask, &func))
+ return NULL;
+ if (!PyFile_Check (file)
+ || !(PyMethod_Check(func) || PyFunction_Check(func)))
+ {
+ PyErr_SetString (PyExc_TypeError, "bad argument list");
+ return NULL;
+ }
+
+ id = fileno (PyFile_AsFile (file));
+ Py_DECREF (file);
+ Tk_CreateFileHandler (id, mask, FileHandler, (ClientData) func);
+ /* XXX fileHandlerDict */
+ Py_INCREF (Py_None);
+ return Py_None;
+}
+
+static PyObject *
+Tkapp_DeleteFileHandler (self, args)
+ PyObject *self;
+ PyObject *args; /* Args: file */
+{
+ int id;
+
+ if (!PyFile_Check (args))
+ {
+ PyErr_SetString (PyExc_TypeError, "bad argument list");
+ return NULL;
+ }
+
+ id = fileno (PyFile_AsFile (args));
+ Tk_DeleteFileHandler (id);
+ /* XXX fileHandlerDict */
+ Py_INCREF (Py_None);
+ return Py_None;
+}
+
+/** Event Loop **/
+
+static int quitMainLoop;
+
+static PyObject *
+Tkapp_MainLoop (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ if (!PyArg_Parse (args, ""))
+ return NULL;
+
+ quitMainLoop = 0;
+ while (tk_NumMainWindows > 0 && !quitMainLoop && !errorInCmd)
+ {
+ if (PyOS_InterruptOccurred ())
+ {
+ PyErr_SetNone (PyExc_KeyboardInterrupt);
+ return NULL;
+ }
+ Tk_DoOneEvent (0);
+ }
+
+ if (errorInCmd)
+ {
+ errorInCmd = 0;
+ PyErr_SetObject (excInCmd, valInCmd);
+ return NULL;
+ }
+ Py_INCREF (Py_None);
+ return Py_None;
+}
+
+static PyObject *
+Tkapp_Quit (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+
+ if (!PyArg_Parse (args, ""))
+ return NULL;
+ quitMainLoop = 1;
+ Py_INCREF (Py_None);
+ return Py_None;
+}
+
+/**** Tkapp Method List ****/
+
+static PyMethodDef Tkapp_methods[] =
+{
+ {"call", Tkapp_Call},
+ {"globalcall", Tkapp_GlobalCall},
+ {"eval", Tkapp_Eval},
+ {"globaleval", Tkapp_GlobalEval},
+ {"evalfile", Tkapp_EvalFile},
+ {"record", Tkapp_Record},
+ {"adderrorinfo", Tkapp_AddErrorInfo},
+ {"setvar", Tkapp_SetVar},
+ {"globalsetvar", Tkapp_GlobalSetVar},
+ {"getvar", Tkapp_GetVar},
+ {"globalgetvar", Tkapp_GlobalGetVar},
+ {"unsetvar", Tkapp_UnsetVar},
+ {"globalunsetvar", Tkapp_GlobalUnsetVar},
+ {"getint", Tkapp_GetInt},
+ {"getdouble", Tkapp_GetDouble},
+ {"getboolean", Tkapp_GetBoolean},
+ {"exprstring", Tkapp_ExprString},
+ {"exprlong", Tkapp_ExprLong},
+ {"exprdouble", Tkapp_ExprDouble},
+ {"exprboolean", Tkapp_ExprBoolean},
+ {"splitlist", Tkapp_SplitList},
+ {"split", Tkapp_Split},
+ {"merge", Tkapp_Merge},
+ {"createcommand", Tkapp_CreateCommand},
+ {"deletecommand", Tkapp_DeleteCommand},
+ {"createfilehandler", Tkapp_CreateFileHandler},
+ {"deletefilehandler", Tkapp_DeleteFileHandler},
+ {"mainloop", Tkapp_MainLoop},
+ {"quit", Tkapp_Quit},
+ {NULL, NULL}
+};
+
+/**** Tkapp Type Methods ****/
+
+static void
+Tkapp_Dealloc (self)
+ PyObject *self;
+{
+ Tk_DestroyWindow (Tkapp_Tkwin (self));
+ Tcl_DeleteInterp (Tkapp_Interp (self));
+ PyMem_DEL (self);
+}
+
+static PyObject *
+Tkapp_GetAttr (self, name)
+ PyObject *self;
+ char *name;
+{
+ return Py_FindMethod (Tkapp_methods, self, name);
+}
+
+static PyTypeObject Tkapp_Type =
+{
+ OB_HEAD_INIT (&PyType_Type)
+ 0, /*ob_size */
+ "tkapp", /*tp_name */
+ sizeof (TkappObject), /*tp_basicsize */
+ 0, /*tp_itemsize */
+ Tkapp_Dealloc, /*tp_dealloc */
+ 0, /*tp_print */
+ Tkapp_GetAttr, /*tp_getattr */
+ 0, /*tp_setattr */
+ 0, /*tp_compare */
+ 0, /*tp_repr */
+ 0, /*tp_as_number */
+ 0, /*tp_as_sequence */
+ 0, /*tp_as_mapping */
+ 0, /*tp_hash */
+};
+
+/**** Tkinter Module ****/
+
+static PyObject *
+Tkinter_Create (self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char *screenName = NULL;
+ char *baseName;
+ char *className;
+ int interactive = 0;
+
+ baseName = strrchr (getprogramname (), '/');
+ if (baseName != NULL)
+ baseName++;
+ else
+ baseName = getprogramname ();
+ className = "Tk";
+
+ if (PyArg_Parse (args, ""))
+ /* VOID */ ;
+ else if (PyArg_Parse (args, "z",
+ &screenName))
+ /* VOID */ ;
+ else if (PyArg_Parse (args, "(zs)",
+ &screenName, &baseName))
+ /* VOID */ ;
+ else if (PyArg_Parse (args, "(zss)",
+ &screenName, &baseName, &className))
+ /* VOID */ ;
+ else if (PyArg_Parse (args, "(zssi)",
+ &screenName, &baseName, &className, &interactive))
+ /* VOID */ ;
+ else
+ return NULL;
+
+ return (PyObject *) Tkapp_New (screenName, baseName, className,
+ interactive);
+}
+
+static PyMethodDef moduleMethods[] =
+{
+ {"create", Tkinter_Create},
+ {NULL, NULL}
+};
+
+#ifdef WITH_READLINE
+static int
+EventHook ()
+{
+ if (errorInCmd) /* XXX Reset tty */
+ {
+ errorInCmd = 0;
+ PyErr_SetObject (excInCmd, valInCmd);
+ PyErr_Print ();
+ }
+ if (tk_NumMainWindows > 0)
+ Tk_DoOneEvent (0);
+ return 0;
+}
+#endif /* WITH_READLINE */
+
+static void
+StdinProc (clientData, mask)
+ ClientData clientData;
+ int mask;
+{
+ /* Do nothing. */
+}
+
+void
+PyInit_tkinter ()
+{
+#ifdef WITH_READLINE
+ extern int (*rl_event_hook) ();
+#endif /* WITH_READLINE */
+ PyObject *m, *d, *v;
+
+ m = Py_InitModule ("tkinter", moduleMethods);
+
+ d = PyModule_GetDict (m);
+ Tkinter_TclError = Py_BuildValue ("s", "TclError");
+ PyDict_SetItemString (d, "TclError", Tkinter_TclError);
+
+ v = Py_BuildValue ("i", TK_READABLE);
+ PyDict_SetItemString (d, "READABLE", v);
+ v = Py_BuildValue ("i", TK_WRITABLE);
+ PyDict_SetItemString (d, "WRITABLE", v);
+ v = Py_BuildValue ("i", TK_EXCEPTION);
+ PyDict_SetItemString (d, "EXCEPTION", v);
+
+ /* Unblock stdin. */
+ Tk_CreateFileHandler (0, TK_READABLE, StdinProc, (ClientData) 0);
+
+#ifdef WITH_READLINE
+ rl_event_hook = EventHook;
+#endif /* WITH_READLINE */
+
+ if (PyErr_Occurred ())
+ Py_FatalError ("can't initialize module tkinter");
+}