#include "Python.h"

#include <ctype.h>

#ifdef WITH_THREAD

#include "pythread.h"

#ifdef MS_WINDOWS

#include <windows.h>

#ifndef PyDoc_STRVAR

#define PyDoc_STRVAR(name,str) static char name[] = str

#ifndef PyMODINIT_FUNC

#define PyMODINIT_FUNC void

#ifndef PyBool_Check

#define PyBool_Check(o) 0

#define PyBool_FromLong PyInt_FromLong

#define USE_COMPAT_CONST

#define TCL_THREADS

#ifdef TK_FRAMEWORK

#include <Tcl/tcl.h>

#include <Tk/tk.h>

#include <tcl.h>

#include <tk.h>

#ifndef CONST84_RETURN

#define CONST84_RETURN

#undef CONST

#define CONST

#define TKMAJORMINOR (TK_MAJOR_VERSION*1000 + TK_MINOR_VERSION)

#if TKMAJORMINOR < 8002

#error "Tk older than 8.2 not supported"

#if TCL_UTF_MAX != 3 && !(defined(Py_UNICODE_WIDE) && TCL_UTF_MAX==6)

#error "unsupported Tcl configuration"

#if !(defined(MS_WINDOWS) || defined(__CYGWIN__))

#define HAVE_CREATEFILEHANDLER

#ifdef HAVE_CREATEFILEHANDLER

#ifdef MS_WINDOWS

#define FHANDLETYPE TCL_WIN_SOCKET

#define FHANDLETYPE TCL_UNIX_FD

#if FHANDLETYPE == TCL_UNIX_FD

#define WAIT_FOR_STDIN

#endif /* HAVE_CREATEFILEHANDLER */

#ifdef MS_WINDOWS

#include <conio.h>

#define WAIT_FOR_STDIN

#ifdef WITH_THREAD

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

static PyThreadState *tcl_tstate = NULL;

#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 \

#define ENTER_TCL

#define LEAVE_TCL

#define ENTER_OVERLAP

#define LEAVE_OVERLAP_TCL

#define ENTER_PYTHON

#define LEAVE_PYTHON

#define CHECK_TCL_APPARTMENT

#ifndef FREECAST

#define FREECAST (char *)

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.

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



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;

}



static int Tkinter_busywaitinterval = 20;

#ifdef WITH_THREAD

#ifndef MS_WINDOWS

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

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



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

}

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.

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;

}

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.

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;

}



#ifndef WITH_APPINIT

Tcl_AppInit(Tcl_Interp *interp)

{

Tk_Window main;

const char * _tkinter_skip_tk_init;

if (Tcl_Init(interp) == TCL_ERROR) {

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

return TCL_ERROR;

}

_tkinter_skip_tk_init = Tcl_GetVar(interp, "_tkinter_skip_tk_init", TCL_GLOBAL_ONLY);

if (_tkinter_skip_tk_init == NULL || strcmp(_tkinter_skip_tk_init, "1") != 0) {

main = Tk_MainWindow(interp);

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



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

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

static TkappObject *

Tkapp_New(char *screenName, char *baseName, char *className,

int interactive, int wantobjects, int wantTk, int sync, char *use)

{

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;

}

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

}

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

/* 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 (! wantTk) {

Tcl_SetVar(v->interp, "_tkinter_skip_tk_init", "1", TCL_GLOBAL_ONLY);

}

/* some initial arguments need to be in argv */

if (sync || use) {

char *args;

int len = 0;

if (sync)

len += sizeof "-sync";

if (use)

len += strlen(use) + sizeof "-use ";

args = (char*)ckalloc(len);

if (!args) {

PyErr_NoMemory();

Py_DECREF(v);

return NULL;

}

args[0] = '\0';

if (sync)

strcat(args, "-sync");

if (use) {

if (sync)

strcat(args, " ");

strcat(args, "-use ");

strcat(args, use);

}

Tcl_SetVar(v->interp, "argv", args, TCL_GLOBAL_ONLY);

ckfree(args);

}

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

PyObject *result = Tkinter_Error((PyObject *)v);

Py_DECREF((PyObject *)v);

return (TkappObject *)result;

}

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

}



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

}

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

}

}

self->string = PyString_FromStringAndSize(s, len);

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

}

static PyObject *

PyTclObject_repr(PyTclObject *self)

{

char buf[50];

PyOS_snprintf(buf, 50, "<%s object at %p>",

self->value->typePtr->name, 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[] = {

#ifdef Py_USING_UNICODE

{"__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)

{

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.

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

}

result = Tcl_NewUnicodeObj(outbuf, size);

ckfree(FREECAST outbuf);

return result;

return Tcl_NewUnicodeObj(inbuf, size);

}

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,

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

}

}

result = PyString_FromStringAndSize(value->bytes, value->length);