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

Copyright (C) 1994 Steen Lumholt.

All Rights Reserved

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

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

/* TCL/TK VERSION INFO:

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:

- 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

#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

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

#else

#include <tcl.h>

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

#if TCL_UTF_MAX != 3

#error "unsupported Tcl configuration"

#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) || defined(__CYGWIN__) || defined(macintosh))

/* Mac has it, but it doesn't really work:-( */

#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

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.

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.

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 \

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

#define LEAVE_TCL \

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; if(tcl_lock)PyThread_release_lock(tcl_lock); }

#define ENTER_PYTHON \

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

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

#define LEAVE_PYTHON \

{ PyThreadState *tstate = PyEval_SaveThread(); \

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

#define ENTER_TCL

#define LEAVE_TCL

#define ENTER_OVERLAP

#define LEAVE_OVERLAP_TCL

#define ENTER_PYTHON

#define LEAVE_PYTHON

#define CHECK_TCL_APPARTMENT

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

static int PyMacConvertEvent(EventRecord *eventPtr);

#include <SIOUX.h>

extern int SIOUXIsAppWindow(WindowPtr);

#endif /* macintosh */

#ifndef FREECAST

#define FREECAST (char *)

#endif

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

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)

#define Tkapp_Interp(v) (((TkappObject *) (v))->interp)

#define Tkapp_Result(v) Tcl_GetStringResult(Tkapp_Interp(v))

#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

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

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

}



static char *

AsString(PyObject *value, PyObject *tmp)

{

if (PyString_Check(value))

return PyString_AsString(value);

#ifdef Py_USING_UNICODE

else if (PyUnicode_Check(value)) {

PyObject *v = PyUnicode_AsUTF8String(value);

if (v == NULL)

return NULL;

if (PyList_Append(tmp, v) != 0) {

Py_DECREF(v);

return NULL;

}

Py_DECREF(v);

return PyString_AsString(v);

}

#endif

else {

PyObject *v = PyObject_Str(value);

if (v == NULL)

return NULL;

if (PyList_Append(tmp, v) != 0) {

Py_DECREF(v);

return NULL;

}

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, fvc = 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;

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

}

else if (v == Py_None) {

argc = i;

break;

}

else {

fv[i] = 0;

if (!(argv[i] = AsString(v, tmp)))

goto finally;

fvc++;

}

}

}

res = Tcl_Merge(argc, argv);

if (res == NULL)

PyErr_SetString(Tkinter_TclError, "merge failed");

finally:

for (i = 0; i < fvc; 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;

}

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

#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", Tcl_GetStringResult(interp));

return TCL_ERROR;

}

if (Tk_Init(interp) == TCL_ERROR) {

PySys_WriteStderr("Tk_Init error: %s\n", Tcl_GetStringResult(interp));

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, int wantobjects)

{

TkappObject *v;

char *argv0;

v = PyObject_New(TkappObject, &Tkapp_Type);

if (v == NULL)

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

if (v->threaded && tcl_lock) {

/* If Tcl is threaded, we don't need the lock. */

PyThread_free_lock(tcl_lock);

tcl_lock = NULL;

}

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

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;

}

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

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

}

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

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

}

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

0, /*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)

{

Tcl_Obj *result;

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

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;

}

#ifdef Py_USING_UNICODE

else if (PyUnicode_Check(value)) {

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

#ifdef Py_UNICODE_WIDE

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

}

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)

return 0;

result = AsObj(v);

Py_DECREF(v);

return result;

}

}

static PyObject*

FromObj(PyObject* tkapp, Tcl_Obj *value)

{

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;

}

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