/***********************************************************

Copyright (C) 1994 Steen Lumholt.

Copyright 1994-1995 by Stichting Mathematisch Centrum, Amsterdam,

The Netherlands.

All Rights Reserved

Copyright (c) 2000, BeOpen.com.

Copyright (c) 1995-2000, Corporation for National Research Initiatives.

Copyright (c) 1990-1995, Stichting Mathematisch Centrum.

All rights reserved.

See the file "Misc/COPYRIGHT" for information on usage and

redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.

******************************************************************/

/* _tkinter.c -- Interface to libtk.a and libtcl.a. */

/* 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

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).

*/

#include "Python.h"

#include <ctype.h>

#ifdef WITH_THREAD

#include "pythread.h"

#endif

#ifdef MS_WINDOWS

#include <windows.h>

#endif

#ifdef macintosh

#define MAC_TCL

#include "myselect.h"

#endif

#ifdef PYOS_OS2

#include "myselect.h"

#endif

#include <tcl.h>

#include <tk.h>

#define TKMAJORMINOR (TK_MAJOR_VERSION*1000 + TK_MINOR_VERSION)

#if TKMAJORMINOR < 8000

#error "Tk older than 8.0 not supported"

#endif

#if defined(macintosh)

/* Sigh, we have to include this to get at the tcl qd pointer */

#include <tkMac.h>

/* And this one we need to clear the menu bar */

#include <Menus.h>

#endif

#if !defined(MS_WINDOWS)

#define HAVE_CREATEFILEHANDLER

#endif

#ifdef HAVE_CREATEFILEHANDLER

/* Tcl_CreateFileHandler() changed several times; these macros deal with the

messiness. In Tcl 8.0 and later, it is not available on Windows (and on

Unix, only because Jack added it back); when available on Windows, it only

applies to sockets. */

#ifdef MS_WINDOWS

#define FHANDLETYPE TCL_WIN_SOCKET

#else

#define FHANDLETYPE TCL_UNIX_FD

#endif

/* If Tcl can wait for a Unix file descriptor, define the EventHook() routine

which uses this to handle Tcl events while the user is typing commands. */

#if FHANDLETYPE == TCL_UNIX_FD

#define WAIT_FOR_STDIN

#endif

#endif /* HAVE_CREATEFILEHANDLER */

#ifdef MS_WINDOWS

#include <conio.h>

#define WAIT_FOR_STDIN

#endif

#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).

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.

To solve this problem, a separate lock for Tcl is introduced. Holding it

is incompatible with holding Python's interpreter lock. The following four

macros manipulate both locks together.

ENTER_TCL and LEAVE_TCL are brackets, just like Py_BEGIN_ALLOW_THREADS and

Py_END_ALLOW_THREADS. They should be used whenever a call into Tcl is made

that could call an event handler, or otherwise affect the state of a Tcl

interpreter. These assume that the surrounding code has the Python

interpreter lock; inside the brackets, the Python interpreter lock has been

released and the lock for Tcl has been acquired.

Sometimes, it is necessary to have both the Python lock and the Tcl lock.

(For example, when transferring data from the Tcl interpreter result to a

Python string object.) This can be done by using different macros to close

the ENTER_TCL block: ENTER_OVERLAP reacquires the Python lock (and restores

the thread state) but doesn't release the Tcl lock; LEAVE_OVERLAP_TCL

releases the Tcl lock.

By contrast, ENTER_PYTHON and LEAVE_PYTHON are used in Tcl event

handlers when the handler needs to use Python. Such event handlers are

entered while the lock for Tcl is held; the event handler presumably needs

to use Python. ENTER_PYTHON releases the lock for Tcl and acquires

the Python interpreter lock, restoring the appropriate thread state, and

LEAVE_PYTHON releases the Python interpreter lock and re-acquires the lock

for Tcl. It is okay for ENTER_TCL/LEAVE_TCL pairs to be contained inside

the code between ENTER_PYTHON and LEAVE_PYTHON.

These locks expand to several statements and brackets; they should not be

used in branches of if statements and the like.

*/

static PyThread_type_lock tcl_lock = 0;

static PyThreadState *tcl_tstate = NULL;

#define ENTER_TCL \

{ PyThreadState *tstate = PyThreadState_Get(); Py_BEGIN_ALLOW_THREADS \

PyThread_acquire_lock(tcl_lock, 1); tcl_tstate = tstate;

#define LEAVE_TCL \

tcl_tstate = NULL; 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); }

#define ENTER_PYTHON \

{ PyThreadState *tstate = tcl_tstate; tcl_tstate = NULL; \

PyThread_release_lock(tcl_lock); PyEval_RestoreThread((tstate)); }

#define LEAVE_PYTHON \

{ PyThreadState *tstate = PyEval_SaveThread(); \

PyThread_acquire_lock(tcl_lock, 1); tcl_tstate = tstate; }

#else

#define ENTER_TCL

#define LEAVE_TCL

#define ENTER_OVERLAP

#define LEAVE_OVERLAP_TCL

#define ENTER_PYTHON

#define LEAVE_PYTHON

#endif

#ifdef macintosh

/*

** Additional cruft needed by Tcl/Tk on the Mac.

** This is for Tcl 7.5 and Tk 4.1 (patch release 1).

*/

/* ckfree() expects a char* */

#define FREECAST (char *)

#include <Events.h> /* For EventRecord */

typedef int (*TclMacConvertEventPtr) (EventRecord *eventPtr);

void Tcl_MacSetEventProc (TclMacConvertEventPtr procPtr);

int TkMacConvertEvent (EventRecord *eventPtr);

staticforward int PyMacConvertEvent (EventRecord *eventPtr);

#if defined(__CFM68K__) && !defined(__USING_STATIC_LIBS__)

#pragma import on

#endif

#include <SIOUX.h>

extern int SIOUXIsAppWindow(WindowPtr);

#if defined(__CFM68K__) && !defined(__USING_STATIC_LIBS__)

#pragma import reset

#endif

#endif /* macintosh */

#ifndef FREECAST

#define FREECAST (char *)

#endif

/**** Tkapp Object Declaration ****/

staticforward PyTypeObject Tkapp_Type;

typedef struct {

PyObject_HEAD

Tcl_Interp *interp;

} TkappObject;

#define Tkapp_Check(v) ((v)->ob_type == &Tkapp_Type)

#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 quitMainLoop = 0;

static int errorInCmd = 0;

static PyObject *excInCmd;

static PyObject *valInCmd;

static PyObject *trbInCmd;



static PyObject *

Tkinter_Error(PyObject *v)

{

PyErr_SetString(Tkinter_TclError, Tkapp_Result(v));

return NULL;

}



/**** Utils ****/

#ifdef WITH_THREAD

#ifndef MS_WINDOWS

#include "mytime.h"

#include "myselect.h"

/* Millisecond sleep() for Unix platforms. */

static void

Sleep(int milli)

{

/* XXX Too bad if you don't have select(). */

struct timeval t;

t.tv_sec = milli/1000;

t.tv_usec = (milli%1000) * 1000;

select(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &t);

}

#endif /* MS_WINDOWS */

#endif /* WITH_THREAD */



static char *

AsString(PyObject *value, PyObject *tmp)

{

if (PyString_Check(value))

return PyString_AsString(value);

else {

PyObject *v = PyObject_Str(value);

PyList_Append(tmp, v);

Py_DECREF(v);

return PyString_AsString(v);

}

}



#define ARGSZ 64

static char *

Merge(PyObject *args)

{

PyObject *tmp = NULL;

char *argvStore[ARGSZ];

char **argv = NULL;

int fvStore[ARGSZ];

int *fv = NULL;

int argc = 0, i;

char *res = NULL;

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;

argv[0] = AsString(args, tmp);

}

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;

}

else if (v == Py_None) {

argc = i;

break;

}

else {

fv[i] = 0;

argv[i] = AsString(v, tmp);

}

}

}

res = Tcl_Merge(argc, argv);

finally:

for (i = 0; i < argc; i++)

if (fv[i]) {

ckfree(argv[i]);

}

if (argv != argvStore)

ckfree(FREECAST argv);

if (fv != fvStore)

ckfree(FREECAST fv);

Py_DECREF(tmp);

return res;

}



static PyObject *

Split(char *list)

{

int argc;

char **argv;

PyObject *v;

if (list == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

if (Tcl_SplitList((Tcl_Interp *)NULL, list, &argc, &argv) != TCL_OK) {

/* Not a list.

* Could be a quoted string containing funnies, e.g. {"}.

* Return the string itself.

*/

return PyString_FromString(list);

}

if (argc == 0)

v = PyString_FromString("");

else if (argc == 1)

v = PyString_FromString(argv[0]);

else if ((v = PyTuple_New(argc)) != NULL) {

int i;

PyObject *w;

for (i = 0; i < argc; i++) {

if ((w = Split(argv[i])) == NULL) {

Py_DECREF(v);

v = NULL;

break;

}

PyTuple_SetItem(v, i, w);

}

}

Tcl_Free(FREECAST argv);

return v;

}



/**** Tkapp Object ****/

#ifndef WITH_APPINIT

int

Tcl_AppInit(Tcl_Interp *interp)

{

Tk_Window main;

main = Tk_MainWindow(interp);

if (Tcl_Init(interp) == TCL_ERROR) {

PySys_WriteStderr("Tcl_Init error: %s\n", interp->result);

return TCL_ERROR;

}

if (Tk_Init(interp) == TCL_ERROR) {

PySys_WriteStderr("Tk_Init error: %s\n", interp->result);

return TCL_ERROR;

}

return TCL_OK;

}

#endif /* !WITH_APPINIT */



/* Initialize the Tk application; see the `main' function in

* `tkMain.c'.

*/

static void EnableEventHook(void); /* Forward */

static void DisableEventHook(void); /* Forward */

static TkappObject *

Tkapp_New(char *screenName, char *baseName, char *className, int interactive)

{

TkappObject *v;

char *argv0;

v = PyObject_New(TkappObject, &Tkapp_Type);

if (v == NULL)

return NULL;

v->interp = Tcl_CreateInterp();

#if defined(macintosh)

/* This seems to be needed */

ClearMenuBar();

TkMacInitMenus(v->interp);

#endif

/* Delete the 'exit' command, which can screw things up */

Tcl_DeleteCommand(v->interp, "exit");

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);

/* This is used to get the application class for Tk 4.1 and up */

argv0 = (char*)ckalloc(strlen(className) + 1);

if (!argv0) {

PyErr_NoMemory();

Py_DECREF(v);

return NULL;

}

strcpy(argv0, className);

if (isupper((int)(argv0[0])))

argv0[0] = tolower(argv0[0]);

Tcl_SetVar(v->interp, "argv0", argv0, TCL_GLOBAL_ONLY);

ckfree(argv0);

if (Tcl_AppInit(v->interp) != TCL_OK)

return (TkappObject *)Tkinter_Error((PyObject *)v);

EnableEventHook();

return v;

}



/** Tcl Eval **/

#if TKMAJORMINOR >= 8001

#define USING_OBJECTS

#endif

#ifdef USING_OBJECTS

static Tcl_Obj*

AsObj(PyObject *value)

{

Tcl_Obj *result;

if (PyString_Check(value))

return Tcl_NewStringObj(PyString_AS_STRING(value),

PyString_GET_SIZE(value));

else if (PyInt_Check(value))

return Tcl_NewLongObj(PyInt_AS_LONG(value));

else if (PyFloat_Check(value))

return Tcl_NewDoubleObj(PyFloat_AS_DOUBLE(value));

else if (PyTuple_Check(value)) {

Tcl_Obj **argv = (Tcl_Obj**)

ckalloc(PyTuple_Size(value)*sizeof(Tcl_Obj*));

int i;

if(!argv)

return 0;

for(i=0;i<PyTuple_Size(value);i++)

argv[i] = AsObj(PyTuple_GetItem(value,i));

result = Tcl_NewListObj(PyTuple_Size(value), argv);

ckfree(FREECAST argv);

return result;

}

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;

}

return Tcl_NewUnicodeObj(PyUnicode_AS_UNICODE(value),

PyUnicode_GET_SIZE(value));

#endif /* TKMAJORMINOR > 8001 */

}

else {

PyObject *v = PyObject_Str(value);

if (!v)

return 0;

result = AsObj(v);

Py_DECREF(v);

return result;

}

}

static PyObject *

Tkapp_Call(PyObject *self, PyObject *args)

{

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;

objv = objStore;

if (args == NULL)

objc = 0;

else if (!PyTuple_Check(args)) {

objc = 1;

objv[0] = AsObj(args);

if (objv[0] == 0)

goto finally;

Tcl_IncrRefCount(objv[0]);

}

else {

objc = PyTuple_Size(args);

if (objc > ARGSZ) {

objv = (Tcl_Obj **)ckalloc(objc * sizeof(char *));

if (objv == NULL) {

PyErr_NoMemory();

goto finally;

}

}

for (i = 0; i < objc; i++) {

PyObject *v = PyTuple_GetItem(args, i);

if (v == Py_None) {

objc = i;

break;

}

objv[i] = AsObj(v);

if (!objv[i])

goto finally;

Tcl_IncrRefCount(objv[i]);

}

}

ENTER_TCL

i = Tcl_EvalObjv(interp, objc, objv, flags);

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;

/* If the result contains any bytes with the top bit set,

it's UTF-8 and we should decode it to Unicode */

while (*p != '\0') {

if (*p & 0x80)

break;

p++;

}

if (*p == '\0')

res = PyString_FromStringAndSize(s, (int)(p-s));

else {

/* Convert UTF-8 to Unicode string */

p = strchr(p, '\0');

res = PyUnicode_DecodeUTF8(s, (int)(p-s), "strict");

if (res == NULL) {

PyErr_Clear();

res = PyString_FromStringAndSize(s, (int)(p-s));

}

}

}

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 */

static PyObject *

Tkapp_Call(PyObject *self, PyObject *args)

{

/* This is copied from Merge() */

PyObject *tmp = NULL;

char *argvStore[ARGSZ];

char **argv = NULL;

int fvStore[ARGSZ];

int *fv = NULL;

int argc = 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;

argv[0] = AsString(args, tmp);

}

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;

}

else if (v == Py_None) {

argc = i;

break;

}

else {

fv[i] = 0;

argv[i] = AsString(v, tmp);

}

}

}

/* End code copied from Merge() */

/* 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);

}

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",

interp->result);

Tkinter_Error(self);

}

else {

if (Py_VerboseFlag >= 2)

PySys_WriteStderr("-> '%s'\n", interp->result);

res = PyString_FromString(interp->result);

}

LEAVE_OVERLAP_TCL

/* Copied from Merge() again */

finally:

for (i = 0; i < argc; i++)

if (fv[i]) {

ckfree(argv[i]);

}

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)

{

/* Could do the same here as for Tkapp_Call(), but this is not used

much, so I can't be bothered. Unfortunately Tcl doesn't export a

way for the user to do what all its Global* variants do (save and

reset the scope pointer, call the local version, restore the saved

scope pointer). */

char *cmd;

PyObject *res = NULL;

cmd = Merge(args);

if (!cmd)

PyErr_SetString(Tkinter_TclError, "merge failed");

else {

int err;

ENTER_TCL

err = Tcl_GlobalEval(Tkapp_Interp(self), cmd);

ENTER_OVERLAP

if (err == TCL_ERROR)

res = Tkinter_Error(self);

else

res = PyString_FromString(Tkapp_Result(self));

LEAVE_OVERLAP_TCL

}

if (cmd)

ckfree(cmd);

return res;

}

static PyObject *

Tkapp_Eval(PyObject *self, PyObject *args)

{

char *script;

PyObject *res = NULL;

int err;

if (!PyArg_ParseTuple(args, "s:eval", &script))

return NULL;

ENTER_TCL

err = Tcl_Eval(Tkapp_Interp(self), script);

ENTER_OVERLAP

if (err == TCL_ERROR)

res = Tkinter_Error(self);

else

res = PyString_FromString(Tkapp_Result(self));

LEAVE_OVERLAP_TCL

return res;

}

static PyObject *

Tkapp_GlobalEval(PyObject *self, PyObject *args)

{

char *script;

PyObject *res = NULL;

int err;

if (!PyArg_ParseTuple(args, "s:globaleval", &script))

return NULL;

ENTER_TCL

err = Tcl_GlobalEval(Tkapp_Interp(self), script);

ENTER_OVERLAP

if (err == TCL_ERROR)

res = Tkinter_Error(self);

else

res = PyString_FromString(Tkapp_Result(self));

LEAVE_OVERLAP_TCL

return res;

}

static PyObject *

Tkapp_EvalFile(PyObject *self, PyObject *args)

{

char *fileName;

PyObject *res = NULL;

int err;

if (!PyArg_ParseTuple(args, "s:evalfile", &fileName))

return NULL;

ENTER_TCL

err = Tcl_EvalFile(Tkapp_Interp(self), fileName);

ENTER_OVERLAP

if (err == TCL_ERROR)

res = Tkinter_Error(self);

else

res = PyString_FromString(Tkapp_Result(self));

LEAVE_OVERLAP_TCL

return res;

}

static PyObject *

Tkapp_Record(PyObject *self, PyObject *args)

{

char *script;

PyObject *res = NULL;

int err;

if (!PyArg_ParseTuple(args, "s", &script))

return NULL;

ENTER_TCL

err = Tcl_RecordAndEval(Tkapp_Interp(self), script, TCL_NO_EVAL);

ENTER_OVERLAP

if (err == TCL_ERROR)

res = Tkinter_Error(self);

else

res = PyString_FromString(Tkapp_Result(self));

LEAVE_OVERLAP_TCL

return res;

}

static PyObject *

Tkapp_AddErrorInfo(PyObject *self, PyObject *args)

{

char *msg;

if (!PyArg_ParseTuple(args, "s:adderrorinfo", &msg))

return NULL;

ENTER_TCL

Tcl_AddErrorInfo(Tkapp_Interp(self), msg);

LEAVE_TCL

Py_INCREF(Py_None);

return Py_None;

}



/** Tcl Variable **/

static PyObject *

SetVar(PyObject *self, PyObject *args, int flags)

{

char *name1, *name2, *ok, *s;

PyObject *newValue;

PyObject *tmp;

tmp = PyList_New(0);

if (!tmp)

return NULL;

if (PyArg_ParseTuple(args, "sO:setvar", &name1, &newValue)) {

/* XXX Merge? */

s = AsString(newValue, tmp);

ENTER_TCL

ok = Tcl_SetVar(Tkapp_Interp(self), name1, s, flags);

LEAVE_TCL

}

else {

PyErr_Clear();

if (PyArg_ParseTuple(args, "ssO:setvar", &name1, &name2, &newValue)) {

s = AsString (newValue, tmp);

ENTER_TCL

ok = Tcl_SetVar2(Tkapp_Interp(self), name1, name2,

s, flags);

LEAVE_TCL

}

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(PyObject *self, PyObject *args)

{

return 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);

}



static PyObject *

GetVar(PyObject *self, PyObject *args, int flags)

{

char *name1, *name2=NULL, *s;

PyObject *res = NULL;

if (!PyArg_ParseTuple(args, "s|s:getvar", &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_OVERLAP

if (s == NULL)

res = Tkinter_Error(self);

else

res = PyString_FromString(s);

LEAVE_OVERLAP_TCL

return res;

}

static PyObject *

Tkapp_GetVar(PyObject *self, PyObject *args)

{

return 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);

}



static PyObject *

UnsetVar(PyObject *self, PyObject *args, int flags)

{

char *name1, *name2=NULL;

PyObject *res = NULL;

int code;

if (!PyArg_ParseTuple(args, "s|s:unsetvar", &name1, &name2))

return NULL;

ENTER_TCL