?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix HAVE_DECL_ISINF/ISNAN test (again).
[python.git] / Modules / _tkinter.c
blob93e7edc546c0d0b78eeea8b90d243cac3b14976b
1 /***********************************************************
2 Copyright (C) 1994 Steen Lumholt.
3
4 All Rights Reserved
5
6 ******************************************************************/
7
8 /* _tkinter.c -- Interface to libtk.a and libtcl.a. */
9
10 /* TCL/TK VERSION INFO:
11
12 Only Tcl/Tk 8.2 and later are supported. Older versions are not
13 supported. (Use Python 2.2 if you cannot upgrade your Tcl/Tk
14 libraries.)
15 */
16
17 /* XXX Further speed-up ideas, involving Tcl 8.0 features:
18
19 - Register a new Tcl type, "Python callable", which can be called more
20 efficiently and passed to Tcl_EvalObj() directly (if this is possible).
21
22 */
23
24
25 #include "Python.h"
26 #include <ctype.h>
27
28 #ifdef WITH_THREAD
29 #include "pythread.h"
30 #endif
31
32 #ifdef MS_WINDOWS
33 #include <windows.h>
34 #endif
35
36 /* Allow using this code in Python 2.[12] */
37 #ifndef PyDoc_STRVAR
38 #define PyDoc_STRVAR(name,str) static char name[] = str
39 #endif
40
41 #ifndef PyMODINIT_FUNC
42 #define PyMODINIT_FUNC void
43 #endif
44
45 #ifndef PyBool_Check
46 #define PyBool_Check(o) 0
47 #define PyBool_FromLong PyInt_FromLong
48 #endif
49
50 /* Starting with Tcl 8.4, many APIs offer const-correctness. Unfortunately,
51 making _tkinter correct for this API means to break earlier
52 versions. USE_COMPAT_CONST allows to make _tkinter work with both 8.4 and
53 earlier versions. Once Tcl releases before 8.4 don't need to be supported
54 anymore, this should go. */
55 #define USE_COMPAT_CONST
56
57 /* If Tcl is compiled for threads, we must also define TCL_THREAD. We define
58 it always; if Tcl is not threaded, the thread functions in
59 Tcl are empty. */
60 #define TCL_THREADS
61
62 #ifdef TK_FRAMEWORK
63 #include <Tcl/tcl.h>
64 #include <Tk/tk.h>
65 #else
66 #include <tcl.h>
67 #include <tk.h>
68 #endif
69
70 /* For Tcl 8.2 and 8.3, CONST* is not defined (except on Cygwin). */
71 #ifndef CONST84_RETURN
72 #define CONST84_RETURN
73 #undef CONST
74 #define CONST
75 #endif
76
77 #define TKMAJORMINOR (TK_MAJOR_VERSION*1000 + TK_MINOR_VERSION)
78
79 #if TKMAJORMINOR < 8002
80 #error "Tk older than 8.2 not supported"
81 #endif
82
83 /* Unicode conversion assumes that Tcl_UniChar is two bytes.
84 We cannot test this directly, so we test UTF-8 size instead,
85 expecting that TCL_UTF_MAX is changed if Tcl ever supports
86 either UTF-16 or UCS-4.
87 Redhat 8 sets TCL_UTF_MAX to 6, and uses wchar_t for
88 Tcl_Unichar. This is also ok as long as Python uses UCS-4,
89 as well.
90 */
91 #if TCL_UTF_MAX != 3 && !(defined(Py_UNICODE_WIDE) && TCL_UTF_MAX==6)
92 #error "unsupported Tcl configuration"
93 #endif
94
95 #if !(defined(MS_WINDOWS) || defined(__CYGWIN__))
96 #define HAVE_CREATEFILEHANDLER
97 #endif
98
99 #ifdef HAVE_CREATEFILEHANDLER
100
101 /* This bit is to ensure that TCL_UNIX_FD is defined and doesn't interfere
102 with the proper calculation of FHANDLETYPE == TCL_UNIX_FD below. */
103 #ifndef TCL_UNIX_FD
104 # ifdef TCL_WIN_SOCKET
105 # define TCL_UNIX_FD (! TCL_WIN_SOCKET)
106 # else
107 # define TCL_UNIX_FD 1
108 # endif
109 #endif
110
111 /* Tcl_CreateFileHandler() changed several times; these macros deal with the
112 messiness. In Tcl 8.0 and later, it is not available on Windows (and on
113 Unix, only because Jack added it back); when available on Windows, it only
114 applies to sockets. */
115
116 #ifdef MS_WINDOWS
117 #define FHANDLETYPE TCL_WIN_SOCKET
118 #else
119 #define FHANDLETYPE TCL_UNIX_FD
120 #endif
121
122 /* If Tcl can wait for a Unix file descriptor, define the EventHook() routine
123 which uses this to handle Tcl events while the user is typing commands. */
124
125 #if FHANDLETYPE == TCL_UNIX_FD
126 #define WAIT_FOR_STDIN
127 #endif
128
129 #endif /* HAVE_CREATEFILEHANDLER */
130
131 #ifdef MS_WINDOWS
132 #include <conio.h>
133 #define WAIT_FOR_STDIN
134 #endif
135
136 #ifdef WITH_THREAD
137
138 /* The threading situation is complicated. Tcl is not thread-safe, except
139 when configured with --enable-threads.
140 So we need to use a lock around all uses of Tcl. Previously, the Python
141 interpreter lock was used for this. However, this causes problems when
142 other Python threads need to run while Tcl is blocked waiting for events.
143
144 To solve this problem, a separate lock for Tcl is introduced. Holding it
145 is incompatible with holding Python's interpreter lock. The following four
146 macros manipulate both locks together.
147
148 ENTER_TCL and LEAVE_TCL are brackets, just like Py_BEGIN_ALLOW_THREADS and
149 Py_END_ALLOW_THREADS. They should be used whenever a call into Tcl is made
150 that could call an event handler, or otherwise affect the state of a Tcl
151 interpreter. These assume that the surrounding code has the Python
152 interpreter lock; inside the brackets, the Python interpreter lock has been
153 released and the lock for Tcl has been acquired.
154
155 Sometimes, it is necessary to have both the Python lock and the Tcl lock.
156 (For example, when transferring data from the Tcl interpreter result to a
157 Python string object.) This can be done by using different macros to close
158 the ENTER_TCL block: ENTER_OVERLAP reacquires the Python lock (and restores
159 the thread state) but doesn't release the Tcl lock; LEAVE_OVERLAP_TCL
160 releases the Tcl lock.
161
162 By contrast, ENTER_PYTHON and LEAVE_PYTHON are used in Tcl event
163 handlers when the handler needs to use Python. Such event handlers are
164 entered while the lock for Tcl is held; the event handler presumably needs
165 to use Python. ENTER_PYTHON releases the lock for Tcl and acquires
166 the Python interpreter lock, restoring the appropriate thread state, and
167 LEAVE_PYTHON releases the Python interpreter lock and re-acquires the lock
168 for Tcl. It is okay for ENTER_TCL/LEAVE_TCL pairs to be contained inside
169 the code between ENTER_PYTHON and LEAVE_PYTHON.
170
171 These locks expand to several statements and brackets; they should not be
172 used in branches of if statements and the like.
173
174 If Tcl is threaded, this approach won't work anymore. The Tcl interpreter is
175 only valid in the thread that created it, and all Tk activity must happen in this
176 thread, also. That means that the mainloop must be invoked in the thread that
177 created the interpreter. Invoking commands from other threads is possible;
178 _tkinter will queue an event for the interpreter thread, which will then
179 execute the command and pass back the result. If the main thread is not in the
180 mainloop, and invoking commands causes an exception; if the main loop is running
181 but not processing events, the command invocation will block.
182
183 In addition, for a threaded Tcl, a single global tcl_tstate won't be sufficient
184 anymore, since multiple Tcl interpreters may simultaneously dispatch in different
185 threads. So we use the Tcl TLS API.
186
187 */
188
189 static PyThread_type_lock tcl_lock = 0;
190
191 #ifdef TCL_THREADS
192 static Tcl_ThreadDataKey state_key;
193 typedef PyThreadState *ThreadSpecificData;
194 #define tcl_tstate (*(PyThreadState**)Tcl_GetThreadData(&state_key, sizeof(PyThreadState*)))
195 #else
196 static PyThreadState *tcl_tstate = NULL;
197 #endif
198
199 #define ENTER_TCL \
200 { PyThreadState *tstate = PyThreadState_Get(); Py_BEGIN_ALLOW_THREADS \
201 if(tcl_lock)PyThread_acquire_lock(tcl_lock, 1); tcl_tstate = tstate;
202
203 #define LEAVE_TCL \
204 tcl_tstate = NULL; if(tcl_lock)PyThread_release_lock(tcl_lock); Py_END_ALLOW_THREADS}
205
206 #define ENTER_OVERLAP \
207 Py_END_ALLOW_THREADS
208
209 #define LEAVE_OVERLAP_TCL \
210 tcl_tstate = NULL; if(tcl_lock)PyThread_release_lock(tcl_lock); }
211
212 #define ENTER_PYTHON \
213 { PyThreadState *tstate = tcl_tstate; tcl_tstate = NULL; \
214 if(tcl_lock)PyThread_release_lock(tcl_lock); PyEval_RestoreThread((tstate)); }
215
216 #define LEAVE_PYTHON \
217 { PyThreadState *tstate = PyEval_SaveThread(); \
218 if(tcl_lock)PyThread_acquire_lock(tcl_lock, 1); tcl_tstate = tstate; }
219
220 #define CHECK_TCL_APPARTMENT \
221 if (((TkappObject *)self)->threaded && \
222 ((TkappObject *)self)->thread_id != Tcl_GetCurrentThread()) { \
223 PyErr_SetString(PyExc_RuntimeError, "Calling Tcl from different appartment"); \
224 return 0; \
225 }
226
227 #else
228
229 #define ENTER_TCL
230 #define LEAVE_TCL
231 #define ENTER_OVERLAP
232 #define LEAVE_OVERLAP_TCL
233 #define ENTER_PYTHON
234 #define LEAVE_PYTHON
235 #define CHECK_TCL_APPARTMENT
236
237 #endif
238
239 #ifndef FREECAST
240 #define FREECAST (char *)
241 #endif
242
243 /**** Tkapp Object Declaration ****/
244
245 static PyTypeObject Tkapp_Type;
246
247 typedef struct {
248 PyObject_HEAD
249 Tcl_Interp *interp;
250 int wantobjects;
251 int threaded; /* True if tcl_platform[threaded] */
252 Tcl_ThreadId thread_id;
253 int dispatching;
254 /* We cannot include tclInt.h, as this is internal.
255 So we cache interesting types here. */
256 Tcl_ObjType *BooleanType;
257 Tcl_ObjType *ByteArrayType;
258 Tcl_ObjType *DoubleType;
259 Tcl_ObjType *IntType;
260 Tcl_ObjType *ListType;
261 Tcl_ObjType *ProcBodyType;
262 Tcl_ObjType *StringType;
263 } TkappObject;
264
265 #define Tkapp_Check(v) (Py_TYPE(v) == &Tkapp_Type)
266 #define Tkapp_Interp(v) (((TkappObject *) (v))->interp)
267 #define Tkapp_Result(v) Tcl_GetStringResult(Tkapp_Interp(v))
268
269 #define DEBUG_REFCNT(v) (printf("DEBUG: id=%p, refcnt=%i\n", \
270 (void *) v, Py_REFCNT(v)))
271
272
273 \f
274 /**** Error Handling ****/
275
276 static PyObject *Tkinter_TclError;
277 static int quitMainLoop = 0;
278 static int errorInCmd = 0;
279 static PyObject *excInCmd;
280 static PyObject *valInCmd;
281 static PyObject *trbInCmd;
282
283
284 \f
285 static PyObject *
286 Tkinter_Error(PyObject *v)
287 {
288 PyErr_SetString(Tkinter_TclError, Tkapp_Result(v));
289 return NULL;
290 }
291
292
293 \f
294 /**** Utils ****/
295
296 static int Tkinter_busywaitinterval = 20;
297
298 #ifdef WITH_THREAD
299 #ifndef MS_WINDOWS
300
301 /* Millisecond sleep() for Unix platforms. */
302
303 static void
304 Sleep(int milli)
305 {
306 /* XXX Too bad if you don't have select(). */
307 struct timeval t;
308 t.tv_sec = milli/1000;
309 t.tv_usec = (milli%1000) * 1000;
310 select(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &t);
311 }
312 #endif /* MS_WINDOWS */
313
314 /* Wait up to 1s for the mainloop to come up. */
315
316 static int
317 WaitForMainloop(TkappObject* self)
318 {
319 int i;
320 for (i = 0; i < 10; i++) {
321 if (self->dispatching)
322 return 1;
323 Py_BEGIN_ALLOW_THREADS
324 Sleep(100);
325 Py_END_ALLOW_THREADS
326 }
327 if (self->dispatching)
328 return 1;
329 PyErr_SetString(PyExc_RuntimeError, "main thread is not in main loop");
330 return 0;
331 }
332 #endif /* WITH_THREAD */
333
334 \f
335 static char *
336 AsString(PyObject *value, PyObject *tmp)
337 {
338 if (PyString_Check(value))
339 return PyString_AsString(value);
340 #ifdef Py_USING_UNICODE
341 else if (PyUnicode_Check(value)) {
342 PyObject *v = PyUnicode_AsUTF8String(value);
343 if (v == NULL)
344 return NULL;
345 if (PyList_Append(tmp, v) != 0) {
346 Py_DECREF(v);
347 return NULL;
348 }
349 Py_DECREF(v);
350 return PyString_AsString(v);
351 }
352 #endif
353 else {
354 PyObject *v = PyObject_Str(value);
355 if (v == NULL)
356 return NULL;
357 if (PyList_Append(tmp, v) != 0) {
358 Py_DECREF(v);
359 return NULL;
360 }
361 Py_DECREF(v);
362 return PyString_AsString(v);
363 }
364 }
365
366
367 \f
368 #define ARGSZ 64
369
370 static char *
371 Merge(PyObject *args)
372 {
373 PyObject *tmp = NULL;
374 char *argvStore[ARGSZ];
375 char **argv = NULL;
376 int fvStore[ARGSZ];
377 int *fv = NULL;
378 int argc = 0, fvc = 0, i;
379 char *res = NULL;
380
381 if (!(tmp = PyList_New(0)))
382 return NULL;
383
384 argv = argvStore;
385 fv = fvStore;
386
387 if (args == NULL)
388 argc = 0;
389
390 else if (!PyTuple_Check(args)) {
391 argc = 1;
392 fv[0] = 0;
393 if (!(argv[0] = AsString(args, tmp)))
394 goto finally;
395 }
396 else {
397 argc = PyTuple_Size(args);
398
399 if (argc > ARGSZ) {
400 argv = (char **)ckalloc(argc * sizeof(char *));
401 fv = (int *)ckalloc(argc * sizeof(int));
402 if (argv == NULL || fv == NULL) {
403 PyErr_NoMemory();
404 goto finally;
405 }
406 }
407
408 for (i = 0; i < argc; i++) {
409 PyObject *v = PyTuple_GetItem(args, i);
410 if (PyTuple_Check(v)) {
411 fv[i] = 1;
412 if (!(argv[i] = Merge(v)))
413 goto finally;
414 fvc++;
415 }
416 else if (v == Py_None) {
417 argc = i;
418 break;
419 }
420 else {
421 fv[i] = 0;
422 if (!(argv[i] = AsString(v, tmp)))
423 goto finally;
424 fvc++;
425 }
426 }
427 }
428 res = Tcl_Merge(argc, argv);
429 if (res == NULL)
430 PyErr_SetString(Tkinter_TclError, "merge failed");
431
432 finally:
433 for (i = 0; i < fvc; i++)
434 if (fv[i]) {
435 ckfree(argv[i]);
436 }
437 if (argv != argvStore)
438 ckfree(FREECAST argv);
439 if (fv != fvStore)
440 ckfree(FREECAST fv);
441
442 Py_DECREF(tmp);
443 return res;
444 }
445
446
447 \f
448 static PyObject *
449 Split(char *list)
450 {
451 int argc;
452 char **argv;
453 PyObject *v;
454
455 if (list == NULL) {
456 Py_INCREF(Py_None);
457 return Py_None;
458 }
459
460 if (Tcl_SplitList((Tcl_Interp *)NULL, list, &argc, &argv) != TCL_OK) {
461 /* Not a list.
462 * Could be a quoted string containing funnies, e.g. {"}.
463 * Return the string itself.
464 */
465 return PyString_FromString(list);
466 }
467
468 if (argc == 0)
469 v = PyString_FromString("");
470 else if (argc == 1)
471 v = PyString_FromString(argv[0]);
472 else if ((v = PyTuple_New(argc)) != NULL) {
473 int i;
474 PyObject *w;
475
476 for (i = 0; i < argc; i++) {
477 if ((w = Split(argv[i])) == NULL) {
478 Py_DECREF(v);
479 v = NULL;
480 break;
481 }
482 PyTuple_SetItem(v, i, w);
483 }
484 }
485 Tcl_Free(FREECAST argv);
486 return v;
487 }
488
489 /* In some cases, Tcl will still return strings that are supposed to be
490 lists. SplitObj walks through a nested tuple, finding string objects that
491 need to be split. */
492
493 static PyObject *
494 SplitObj(PyObject *arg)
495 {
496 if (PyTuple_Check(arg)) {
497 int i, size;
498 PyObject *elem, *newelem, *result;
499
500 size = PyTuple_Size(arg);
501 result = NULL;
502 /* Recursively invoke SplitObj for all tuple items.
503 If this does not return a new object, no action is
504 needed. */
505 for(i = 0; i < size; i++) {
506 elem = PyTuple_GetItem(arg, i);
507 newelem = SplitObj(elem);
508 if (!newelem) {
509 Py_XDECREF(result);
510 return NULL;
511 }
512 if (!result) {
513 int k;
514 if (newelem == elem) {
515 Py_DECREF(newelem);
516 continue;
517 }
518 result = PyTuple_New(size);
519 if (!result)
520 return NULL;
521 for(k = 0; k < i; k++) {
522 elem = PyTuple_GetItem(arg, k);
523 Py_INCREF(elem);
524 PyTuple_SetItem(result, k, elem);
525 }
526 }
527 PyTuple_SetItem(result, i, newelem);
528 }
529 if (result)
530 return result;
531 /* Fall through, returning arg. */
532 }
533 else if (PyString_Check(arg)) {
534 int argc;
535 char **argv;
536 char *list = PyString_AsString(arg);
537
538 if (Tcl_SplitList((Tcl_Interp *)NULL, list, &argc, &argv) != TCL_OK) {
539 Py_INCREF(arg);
540 return arg;
541 }
542 Tcl_Free(FREECAST argv);
543 if (argc > 1)
544 return Split(PyString_AsString(arg));
545 /* Fall through, returning arg. */
546 }
547 Py_INCREF(arg);
548 return arg;
549 }
550
551 \f
552 /**** Tkapp Object ****/
553
554 #ifndef WITH_APPINIT
555 int
556 Tcl_AppInit(Tcl_Interp *interp)
557 {
558 Tk_Window main;
559 const char * _tkinter_skip_tk_init;
560
561 if (Tcl_Init(interp) == TCL_ERROR) {
562 PySys_WriteStderr("Tcl_Init error: %s\n", Tcl_GetStringResult(interp));
563 return TCL_ERROR;
564 }
565 _tkinter_skip_tk_init = Tcl_GetVar(interp, "_tkinter_skip_tk_init", TCL_GLOBAL_ONLY);
566 if (_tkinter_skip_tk_init == NULL || strcmp(_tkinter_skip_tk_init, "1") != 0) {
567 main = Tk_MainWindow(interp);
568 if (Tk_Init(interp) == TCL_ERROR) {
569 PySys_WriteStderr("Tk_Init error: %s\n", Tcl_GetStringResult(interp));
570 return TCL_ERROR;
571 }
572 }
573 return TCL_OK;
574 }
575 #endif /* !WITH_APPINIT */
576
577
578 \f
579
580 /* Initialize the Tk application; see the `main' function in
581 * `tkMain.c'.
582 */
583
584 static void EnableEventHook(void); /* Forward */
585 static void DisableEventHook(void); /* Forward */
586
587 static TkappObject *
588 Tkapp_New(char *screenName, char *baseName, char *className,
589 int interactive, int wantobjects, int wantTk, int sync, char *use)
590 {
591 TkappObject *v;
592 char *argv0;
593
594 v = PyObject_New(TkappObject, &Tkapp_Type);
595 if (v == NULL)
596 return NULL;
597
598 v->interp = Tcl_CreateInterp();
599 v->wantobjects = wantobjects;
600 v->threaded = Tcl_GetVar2Ex(v->interp, "tcl_platform", "threaded",
601 TCL_GLOBAL_ONLY) != NULL;
602 v->thread_id = Tcl_GetCurrentThread();
603 v->dispatching = 0;
604
605 #ifndef TCL_THREADS
606 if (v->threaded) {
607 PyErr_SetString(PyExc_RuntimeError, "Tcl is threaded but _tkinter is not");
608 Py_DECREF(v);
609 return 0;
610 }
611 #endif
612 #ifdef WITH_THREAD
613 if (v->threaded && tcl_lock) {
614 /* If Tcl is threaded, we don't need the lock. */
615 PyThread_free_lock(tcl_lock);
616 tcl_lock = NULL;
617 }
618 #endif
619
620 v->BooleanType = Tcl_GetObjType("boolean");
621 v->ByteArrayType = Tcl_GetObjType("bytearray");
622 v->DoubleType = Tcl_GetObjType("double");
623 v->IntType = Tcl_GetObjType("int");
624 v->ListType = Tcl_GetObjType("list");
625 v->ProcBodyType = Tcl_GetObjType("procbody");
626 v->StringType = Tcl_GetObjType("string");
627
628 /* Delete the 'exit' command, which can screw things up */
629 Tcl_DeleteCommand(v->interp, "exit");
630
631 if (screenName != NULL)
632 Tcl_SetVar2(v->interp, "env", "DISPLAY",
633 screenName, TCL_GLOBAL_ONLY);
634
635 if (interactive)
636 Tcl_SetVar(v->interp, "tcl_interactive", "1", TCL_GLOBAL_ONLY);
637 else
638 Tcl_SetVar(v->interp, "tcl_interactive", "0", TCL_GLOBAL_ONLY);
639
640 /* This is used to get the application class for Tk 4.1 and up */
641 argv0 = (char*)ckalloc(strlen(className) + 1);
642 if (!argv0) {
643 PyErr_NoMemory();
644 Py_DECREF(v);
645 return NULL;
646 }
647
648 strcpy(argv0, className);
649 if (isupper(Py_CHARMASK(argv0[0])))
650 argv0[0] = tolower(Py_CHARMASK(argv0[0]));
651 Tcl_SetVar(v->interp, "argv0", argv0, TCL_GLOBAL_ONLY);
652 ckfree(argv0);
653
654 if (! wantTk) {
655 Tcl_SetVar(v->interp, "_tkinter_skip_tk_init", "1", TCL_GLOBAL_ONLY);
656 }
657
658 /* some initial arguments need to be in argv */
659 if (sync || use) {
660 char *args;
661 int len = 0;
662
663 if (sync)
664 len += sizeof "-sync";
665 if (use)
666 len += strlen(use) + sizeof "-use ";
667
668 args = (char*)ckalloc(len);
669 if (!args) {
670 PyErr_NoMemory();
671 Py_DECREF(v);
672 return NULL;
673 }
674
675 args[0] = '\0';
676 if (sync)
677 strcat(args, "-sync");
678 if (use) {
679 if (sync)
680 strcat(args, " ");
681 strcat(args, "-use ");
682 strcat(args, use);
683 }
684
685 Tcl_SetVar(v->interp, "argv", args, TCL_GLOBAL_ONLY);
686 ckfree(args);
687 }
688
689 if (Tcl_AppInit(v->interp) != TCL_OK) {
690 PyObject *result = Tkinter_Error((PyObject *)v);
691 Py_DECREF((PyObject *)v);
692 return (TkappObject *)result;
693 }
694
695 EnableEventHook();
696
697 return v;
698 }
699
700
701 static void
702 Tkapp_ThreadSend(TkappObject *self, Tcl_Event *ev,
703 Tcl_Condition *cond, Tcl_Mutex *mutex)
704 {
705 Py_BEGIN_ALLOW_THREADS;
706 Tcl_MutexLock(mutex);
707 Tcl_ThreadQueueEvent(self->thread_id, ev, TCL_QUEUE_TAIL);
708 Tcl_ThreadAlert(self->thread_id);
709 Tcl_ConditionWait(cond, mutex, NULL);
710 Tcl_MutexUnlock(mutex);
711 Py_END_ALLOW_THREADS
712 }
713
714 \f
715 /** Tcl Eval **/
716
717 typedef struct {
718 PyObject_HEAD
719 Tcl_Obj *value;
720 PyObject *string; /* This cannot cause cycles. */
721 } PyTclObject;
722
723 staticforward PyTypeObject PyTclObject_Type;
724 #define PyTclObject_Check(v) ((v)->ob_type == &PyTclObject_Type)
725
726 static PyObject *
727 newPyTclObject(Tcl_Obj *arg)
728 {
729 PyTclObject *self;
730 self = PyObject_New(PyTclObject, &PyTclObject_Type);
731 if (self == NULL)
732 return NULL;
733 Tcl_IncrRefCount(arg);
734 self->value = arg;
735 self->string = NULL;
736 return (PyObject*)self;
737 }
738
739 static void
740 PyTclObject_dealloc(PyTclObject *self)
741 {
742 Tcl_DecrRefCount(self->value);
743 Py_XDECREF(self->string);
744 PyObject_Del(self);
745 }
746
747 static PyObject *
748 PyTclObject_str(PyTclObject *self)
749 {
750 if (self->string && PyString_Check(self->string)) {
751 Py_INCREF(self->string);
752 return self->string;
753 }
754 /* XXX Could cache value if it is an ASCII string. */
755 return PyString_FromString(Tcl_GetString(self->value));
756 }
757
758 static char*
759 PyTclObject_TclString(PyObject *self)
760 {
761 return Tcl_GetString(((PyTclObject*)self)->value);
762 }
763
764 /* Like _str, but create Unicode if necessary. */
765 PyDoc_STRVAR(PyTclObject_string__doc__,
766 "the string representation of this object, either as string or Unicode");
767
768 static PyObject *
769 PyTclObject_string(PyTclObject *self, void *ignored)
770 {
771 char *s;
772 int i, len;
773 if (!self->string) {
774 s = Tcl_GetStringFromObj(self->value, &len);
775 for (i = 0; i < len; i++)
776 if (s[i] & 0x80)
777 break;
778 #ifdef Py_USING_UNICODE
779 if (i == len)
780 /* It is an ASCII string. */
781 self->string = PyString_FromStringAndSize(s, len);
782 else {
783 self->string = PyUnicode_DecodeUTF8(s, len, "strict");
784 if (!self->string) {
785 PyErr_Clear();
786 self->string = PyString_FromStringAndSize(s, len);
787 }
788 }
789 #else
790 self->string = PyString_FromStringAndSize(s, len);
791 #endif
792 if (!self->string)
793 return NULL;
794 }
795 Py_INCREF(self->string);
796 return self->string;
797 }
798
799 #ifdef Py_USING_UNICODE
800 PyDoc_STRVAR(PyTclObject_unicode__doc__, "convert argument to unicode");
801
802 static PyObject *
803 PyTclObject_unicode(PyTclObject *self, void *ignored)
804 {
805 char *s;
806 int len;
807 if (self->string && PyUnicode_Check(self->string)) {
808 Py_INCREF(self->string);
809 return self->string;
810 }
811 /* XXX Could chache result if it is non-ASCII. */
812 s = Tcl_GetStringFromObj(self->value, &len);
813 return PyUnicode_DecodeUTF8(s, len, "strict");
814 }
815 #endif
816
817 static PyObject *
818 PyTclObject_repr(PyTclObject *self)
819 {
820 char buf[50];
821 PyOS_snprintf(buf, 50, "<%s object at %p>",
822 self->value->typePtr->name, self->value);
823 return PyString_FromString(buf);
824 }
825
826 static int
827 PyTclObject_cmp(PyTclObject *self, PyTclObject *other)
828 {
829 int res;
830 res = strcmp(Tcl_GetString(self->value),
831 Tcl_GetString(other->value));
832 if (res < 0) return -1;
833 if (res > 0) return 1;
834 return 0;
835 }
836
837 PyDoc_STRVAR(get_typename__doc__, "name of the Tcl type");
838
839 static PyObject*
840 get_typename(PyTclObject* obj, void* ignored)
841 {
842 return PyString_FromString(obj->value->typePtr->name);
843 }
844
845
846 static PyGetSetDef PyTclObject_getsetlist[] = {
847 {"typename", (getter)get_typename, NULL, get_typename__doc__},
848 {"string", (getter)PyTclObject_string, NULL,
849 PyTclObject_string__doc__},
850 {0},
851 };
852
853 static PyMethodDef PyTclObject_methods[] = {
854 #ifdef Py_USING_UNICODE
855 {"__unicode__", (PyCFunction)PyTclObject_unicode, METH_NOARGS,
856 PyTclObject_unicode__doc__},
857 #endif
858 {0}
859 };
860
861 statichere PyTypeObject PyTclObject_Type = {
862 PyObject_HEAD_INIT(NULL)
863 0, /*ob_size*/
864 "_tkinter.Tcl_Obj", /*tp_name*/
865 sizeof(PyTclObject), /*tp_basicsize*/
866 0, /*tp_itemsize*/
867 /* methods */
868 (destructor)PyTclObject_dealloc, /*tp_dealloc*/
869 0, /*tp_print*/
870 0, /*tp_getattr*/
871 0, /*tp_setattr*/
872 (cmpfunc)PyTclObject_cmp, /*tp_compare*/
873 (reprfunc)PyTclObject_repr, /*tp_repr*/
874 0, /*tp_as_number*/
875 0, /*tp_as_sequence*/
876 0, /*tp_as_mapping*/
877 0, /*tp_hash*/
878 0, /*tp_call*/
879 (reprfunc)PyTclObject_str, /*tp_str*/
880 PyObject_GenericGetAttr,/*tp_getattro*/
881 0, /*tp_setattro*/
882 0, /*tp_as_buffer*/
883 Py_TPFLAGS_DEFAULT, /*tp_flags*/
884 0, /*tp_doc*/
885 0, /*tp_traverse*/
886 0, /*tp_clear*/
887 0, /*tp_richcompare*/
888 0, /*tp_weaklistoffset*/
889 0, /*tp_iter*/
890 0, /*tp_iternext*/
891 PyTclObject_methods, /*tp_methods*/
892 0, /*tp_members*/
893 PyTclObject_getsetlist, /*tp_getset*/
894 0, /*tp_base*/
895 0, /*tp_dict*/
896 0, /*tp_descr_get*/
897 0, /*tp_descr_set*/
898 0, /*tp_dictoffset*/
899 0, /*tp_init*/
900 0, /*tp_alloc*/
901 0, /*tp_new*/
902 0, /*tp_free*/
903 0, /*tp_is_gc*/
904 };
905
906 static Tcl_Obj*
907 AsObj(PyObject *value)
908 {
909 Tcl_Obj *result;
910
911 if (PyString_Check(value))
912 return Tcl_NewStringObj(PyString_AS_STRING(value),
913 PyString_GET_SIZE(value));
914 else if (PyBool_Check(value))
915 return Tcl_NewBooleanObj(PyObject_IsTrue(value));
916 else if (PyInt_Check(value))
917 return Tcl_NewLongObj(PyInt_AS_LONG(value));
918 else if (PyFloat_Check(value))
919 return Tcl_NewDoubleObj(PyFloat_AS_DOUBLE(value));
920 else if (PyTuple_Check(value)) {
921 Tcl_Obj **argv = (Tcl_Obj**)
922 ckalloc(PyTuple_Size(value)*sizeof(Tcl_Obj*));
923 int i;
924 if(!argv)
925 return 0;
926 for(i=0;i<PyTuple_Size(value);i++)
927 argv[i] = AsObj(PyTuple_GetItem(value,i));
928 result = Tcl_NewListObj(PyTuple_Size(value), argv);
929 ckfree(FREECAST argv);
930 return result;
931 }
932 #ifdef Py_USING_UNICODE
933 else if (PyUnicode_Check(value)) {
934 Py_UNICODE *inbuf = PyUnicode_AS_UNICODE(value);
935 Py_ssize_t size = PyUnicode_GET_SIZE(value);
936 /* This #ifdef assumes that Tcl uses UCS-2.
937 See TCL_UTF_MAX test above. */
938 #if defined(Py_UNICODE_WIDE) && TCL_UTF_MAX == 3
939 Tcl_UniChar *outbuf = NULL;
940 Py_ssize_t i;
941 size_t allocsize = ((size_t)size) * sizeof(Tcl_UniChar);
942 if (allocsize >= size)
943 outbuf = (Tcl_UniChar*)ckalloc(allocsize);
944 /* Else overflow occurred, and we take the next exit */
945 if (!outbuf) {
946 PyErr_NoMemory();
947 return NULL;
948 }
949 for (i = 0; i < size; i++) {
950 if (inbuf[i] >= 0x10000) {
951 /* Tcl doesn't do UTF-16, yet. */
952 PyErr_SetString(PyExc_ValueError,
953 "unsupported character");
954 ckfree(FREECAST outbuf);
955 return NULL;
956 }
957 outbuf[i] = inbuf[i];
958 }
959 result = Tcl_NewUnicodeObj(outbuf, size);
960 ckfree(FREECAST outbuf);
961 return result;
962 #else
963 return Tcl_NewUnicodeObj(inbuf, size);
964 #endif
965
966 }
967 #endif
968 else if(PyTclObject_Check(value)) {
969 Tcl_Obj *v = ((PyTclObject*)value)->value;
970 Tcl_IncrRefCount(v);
971 return v;
972 }
973 else {
974 PyObject *v = PyObject_Str(value);
975 if (!v)
976 return 0;
977 result = AsObj(v);
978 Py_DECREF(v);
979 return result;
980 }
981 }
982
983 static PyObject*
984 FromObj(PyObject* tkapp, Tcl_Obj *value)
985 {
986 PyObject *result = NULL;
987 TkappObject *app = (TkappObject*)tkapp;
988
989 if (value->typePtr == NULL) {
990 /* If the result contains any bytes with the top bit set,
991 it's UTF-8 and we should decode it to Unicode */
992 #ifdef Py_USING_UNICODE
993 int i;
994 char *s = value->bytes;
995 int len = value->length;
996 for (i = 0; i < len; i++) {
997 if (value->bytes[i] & 0x80)
998 break;
999 }
1000
1001 if (i == value->length)
1002 result = PyString_FromStringAndSize(s, len);
1003 else {
1004 /* Convert UTF-8 to Unicode string */
1005 result = PyUnicode_DecodeUTF8(s, len, "strict");
1006 if (result == NULL) {
1007 PyErr_Clear();
1008 result = PyString_FromStringAndSize(s, len);
1009 }
1010 }
1011 #else
1012 result = PyString_FromStringAndSize(value->bytes, value->length);
1013 #endif
1014 return result;
1015 }
1016
1017 if (value->typePtr == app->BooleanType) {
1018 result = value->internalRep.longValue ? Py_True : Py_False;
1019 Py_INCREF(result);
1020 return result;
1021 }
1022
1023 if (value->typePtr == app->ByteArrayType) {
1024 int size;
1025 char *data = (char*)Tcl_GetByteArrayFromObj(value, &size);
1026 return PyString_FromStringAndSize(data, size);
1027 }
1028
1029 if (value->typePtr == app->DoubleType) {
1030 return PyFloat_FromDouble(value->internalRep.doubleValue);
1031 }
1032
1033 if (value->typePtr == app->IntType) {
1034 return PyInt_FromLong(value->internalRep.longValue);
1035 }
1036
1037 if (value->typePtr == app->ListType) {
1038 int size;
1039 int i, status;
1040 PyObject *elem;
1041 Tcl_Obj *tcl_elem;
1042
1043 status = Tcl_ListObjLength(Tkapp_Interp(tkapp), value, &size);
1044 if (status == TCL_ERROR)
1045 return Tkinter_Error(tkapp);
1046 result = PyTuple_New(size);
1047 if (!result)
1048 return NULL;
1049 for (i = 0; i < size; i++) {
1050 status = Tcl_ListObjIndex(Tkapp_Interp(tkapp),
1051 value, i, &tcl_elem);
1052 if (status == TCL_ERROR) {
1053 Py_DECREF(result);
1054 return Tkinter_Error(tkapp);
1055 }
1056 elem = FromObj(tkapp, tcl_elem);
1057 if (!elem) {
1058 Py_DECREF(result);
1059 return NULL;
1060 }
1061 PyTuple_SetItem(result, i, elem);
1062 }
1063 return result;
1064 }
1065
1066 if (value->typePtr == app->ProcBodyType) {
1067 /* fall through: return tcl object. */
1068 }
1069
1070 if (value->typePtr == app->StringType) {
1071 #ifdef Py_USING_UNICODE
1072 #if defined(Py_UNICODE_WIDE) && TCL_UTF_MAX==3
1073 PyObject *result;
1074 int size;
1075 Tcl_UniChar *input;
1076 Py_UNICODE *output;
1077
1078 size = Tcl_GetCharLength(value);
1079 result = PyUnicode_FromUnicode(NULL, size);
1080 if (!result)
1081 return NULL;
1082 input = Tcl_GetUnicode(value);
1083 output = PyUnicode_AS_UNICODE(result);
1084 while (size--)
1085 *output++ = *input++;
1086 return result;
1087 #else
1088 return PyUnicode_FromUnicode(Tcl_GetUnicode(value),
1089 Tcl_GetCharLength(value));
1090 #endif
1091 #else
1092 int size;
1093 char *c;
1094 c = Tcl_GetStringFromObj(value, &size);
1095 return PyString_FromStringAndSize(c, size);
1096 #endif
1097 }
1098
1099 return newPyTclObject(value);
1100 }
1101
1102 /* This mutex synchronizes inter-thread command calls. */
1103
1104 TCL_DECLARE_MUTEX(call_mutex)
1105
1106 typedef struct Tkapp_CallEvent {
1107 Tcl_Event ev; /* Must be first */
1108 TkappObject *self;
1109 PyObject *args;
1110 int flags;
1111 PyObject **res;
1112 PyObject **exc_type, **exc_value, **exc_tb;
1113 Tcl_Condition done;
1114 } Tkapp_CallEvent;
1115
1116 void
1117 Tkapp_CallDeallocArgs(Tcl_Obj** objv, Tcl_Obj** objStore, int objc)
1118 {
1119 int i;
1120 for (i = 0; i < objc; i++)
1121 Tcl_DecrRefCount(objv[i]);
1122 if (objv != objStore)
1123 ckfree(FREECAST objv);
1124 }
1125
1126 /* Convert Python objects to Tcl objects. This must happen in the
1127 interpreter thread, which may or may not be the calling thread. */
1128
1129 static Tcl_Obj**
1130 Tkapp_CallArgs(PyObject *args, Tcl_Obj** objStore, int *pobjc)
1131 {
1132 Tcl_Obj **objv = objStore;
1133 int objc = 0, i;
1134 if (args == NULL)
1135 /* do nothing */;
1136
1137 else if (!PyTuple_Check(args)) {
1138 objv[0] = AsObj(args);
1139 if (objv[0] == 0)
1140 goto finally;
1141 objc = 1;
1142 Tcl_IncrRefCount(objv[0]);
1143 }
1144 else {
1145 objc = PyTuple_Size(args);
1146
1147 if (objc > ARGSZ) {
1148 objv = (Tcl_Obj **)ckalloc(objc * sizeof(char *));
1149 if (objv == NULL) {
1150 PyErr_NoMemory();
1151 objc = 0;
1152 goto finally;
1153 }
1154 }
1155
1156 for (i = 0; i < objc; i++) {
1157 PyObject *v = PyTuple_GetItem(args, i);
1158 if (v == Py_None) {
1159 objc = i;
1160 break;
1161 }
1162 objv[i] = AsObj(v);
1163 if (!objv[i]) {
1164 /* Reset objc, so it attempts to clear
1165 objects only up to i. */
1166 objc = i;
1167 goto finally;
1168 }
1169 Tcl_IncrRefCount(objv[i]);
1170 }
1171 }
1172 *pobjc = objc;
1173 return objv;
1174 finally:
1175 Tkapp_CallDeallocArgs(objv, objStore, objc);
1176 return NULL;
1177 }
1178
1179 /* Convert the results of a command call into a Python objects. */
1180
1181 static PyObject*
1182 Tkapp_CallResult(TkappObject *self)
1183 {
1184 PyObject *res = NULL;
1185 if(self->wantobjects) {
1186 Tcl_Obj *value = Tcl_GetObjResult(self->interp);
1187 /* Not sure whether the IncrRef is necessary, but something
1188 may overwrite the interpreter result while we are
1189 converting it. */
1190 Tcl_IncrRefCount(value);
1191 res = FromObj((PyObject*)self, value);
1192 Tcl_DecrRefCount(value);
1193 } else {
1194 const char *s = Tcl_GetStringResult(self->interp);
1195 const char *p = s;
1196
1197 /* If the result contains any bytes with the top bit set,
1198 it's UTF-8 and we should decode it to Unicode */
1199 #ifdef Py_USING_UNICODE
1200 while (*p != '\0') {
1201 if (*p & 0x80)
1202 break;
1203 p++;
1204 }
1205
1206 if (*p == '\0')
1207 res = PyString_FromStringAndSize(s, (int)(p-s));
1208 else {
1209 /* Convert UTF-8 to Unicode string */
1210 p = strchr(p, '\0');
1211 res = PyUnicode_DecodeUTF8(s, (int)(p-s), "strict");
1212 if (res == NULL) {
1213 PyErr_Clear();
1214 res = PyString_FromStringAndSize(s, (int)(p-s));
1215 }
1216 }
1217 #else
1218 p = strchr(p, '\0');
1219 res = PyString_FromStringAndSize(s, (int)(p-s));
1220 #endif
1221 }
1222 return res;
1223 }
1224
1225 /* Tkapp_CallProc is the event procedure that is executed in the context of
1226 the Tcl interpreter thread. Initially, it holds the Tcl lock, and doesn't
1227 hold the Python lock. */
1228
1229 static int
1230 Tkapp_CallProc(Tkapp_CallEvent *e, int flags)
1231 {
1232 Tcl_Obj *objStore[ARGSZ];
1233 Tcl_Obj **objv;
1234 int objc;
1235 int i;
1236 ENTER_PYTHON
1237 objv = Tkapp_CallArgs(e->args, objStore, &objc);
1238 if (!objv) {
1239 PyErr_Fetch(e->exc_type, e->exc_value, e->exc_tb);
1240 *(e->res) = NULL;
1241 }
1242 LEAVE_PYTHON
1243 if (!objv)
1244 goto done;
1245 i = Tcl_EvalObjv(e->self->interp, objc, objv, e->flags);
1246 ENTER_PYTHON
1247 if (i == TCL_ERROR) {
1248 *(e->res) = NULL;
1249 *(e->exc_type) = NULL;
1250 *(e->exc_tb) = NULL;
1251 *(e->exc_value) = PyObject_CallFunction(
1252 Tkinter_TclError, "s",
1253 Tcl_GetStringResult(e->self->interp));
1254 }
1255 else {
1256 *(e->res) = Tkapp_CallResult(e->self);
1257 }
1258 LEAVE_PYTHON
1259 done:
1260 /* Wake up calling thread. */
1261 Tcl_MutexLock(&call_mutex);
1262 Tcl_ConditionNotify(&e->done);
1263 Tcl_MutexUnlock(&call_mutex);
1264 return 1;
1265 }
1266
1267 /* This is the main entry point for calling a Tcl command.
1268 It supports three cases, with regard to threading:
1269 1. Tcl is not threaded: Must have the Tcl lock, then can invoke command in
1270 the context of the calling thread.
1271 2. Tcl is threaded, caller of the command is in the interpreter thread:
1272 Execute the command in the calling thread. Since the Tcl lock will
1273 not be used, we can merge that with case 1.
1274 3. Tcl is threaded, caller is in a different thread: Must queue an event to
1275 the interpreter thread. Allocation of Tcl objects needs to occur in the
1276 interpreter thread, so we ship the PyObject* args to the target thread,
1277 and perform processing there. */
1278
1279 static PyObject *
1280 Tkapp_Call(PyObject *selfptr, PyObject *args)
1281 {
1282 Tcl_Obj *objStore[ARGSZ];
1283 Tcl_Obj **objv = NULL;
1284 int objc, i;
1285 PyObject *res = NULL;
1286 TkappObject *self = (TkappObject*)selfptr;
1287 /* Could add TCL_EVAL_GLOBAL if wrapped by GlobalCall... */
1288 int flags = TCL_EVAL_DIRECT;
1289
1290 /* If args is a single tuple, replace with contents of tuple */
1291 if (1 == PyTuple_Size(args)){
1292 PyObject* item = PyTuple_GetItem(args, 0);
1293 if (PyTuple_Check(item))
1294 args = item;
1295 }
1296 #ifdef WITH_THREAD
1297 if (self->threaded && self->thread_id != Tcl_GetCurrentThread()) {
1298 /* We cannot call the command directly. Instead, we must
1299 marshal the parameters to the interpreter thread. */
1300 Tkapp_CallEvent *ev;
1301 PyObject *exc_type, *exc_value, *exc_tb;
1302 if (!WaitForMainloop(self))
1303 return NULL;
1304 ev = (Tkapp_CallEvent*)ckalloc(sizeof(Tkapp_CallEvent));
1305 ev->ev.proc = (Tcl_EventProc*)Tkapp_CallProc;
1306 ev->self = self;
1307 ev->args = args;
1308 ev->res = &res;
1309 ev->exc_type = &exc_type;
1310 ev->exc_value = &exc_value;
1311 ev->exc_tb = &exc_tb;
1312 ev->done = (Tcl_Condition)0;
1313
1314 Tkapp_ThreadSend(self, (Tcl_Event*)ev, &ev->done, &call_mutex);
1315
1316 if (res == NULL) {
1317 if (exc_type)
1318 PyErr_Restore(exc_type, exc_value, exc_tb);
1319 else
1320 PyErr_SetObject(Tkinter_TclError, exc_value);
1321 }
1322 }
1323 else
1324 #endif
1325 {
1326
1327 objv = Tkapp_CallArgs(args, objStore, &objc);
1328 if (!objv)
1329 return NULL;
1330
1331 ENTER_TCL
1332
1333 i = Tcl_EvalObjv(self->interp, objc, objv, flags);
1334
1335 ENTER_OVERLAP
1336
1337 if (i == TCL_ERROR)
1338 Tkinter_Error(selfptr);
1339 else
1340 res = Tkapp_CallResult(self);
1341
1342 LEAVE_OVERLAP_TCL
1343
1344 Tkapp_CallDeallocArgs(objv, objStore, objc);
1345 }
1346 return res;
1347 }
1348
1349
1350 static PyObject *
1351 Tkapp_GlobalCall(PyObject *self, PyObject *args)
1352 {
1353 /* Could do the same here as for Tkapp_Call(), but this is not used
1354 much, so I can't be bothered. Unfortunately Tcl doesn't export a
1355 way for the user to do what all its Global* variants do (save and
1356 reset the scope pointer, call the local version, restore the saved
1357 scope pointer). */
1358
1359 char *cmd;
1360 PyObject *res = NULL;
1361
1362 CHECK_TCL_APPARTMENT;
1363
1364 cmd = Merge(args);
1365 if (cmd) {
1366 int err;
1367 ENTER_TCL
1368 err = Tcl_GlobalEval(Tkapp_Interp(self), cmd);
1369 ENTER_OVERLAP
1370 if (err == TCL_ERROR)
1371 res = Tkinter_Error(self);
1372 else
1373 res = PyString_FromString(Tkapp_Result(self));
1374 LEAVE_OVERLAP_TCL
1375 ckfree(cmd);
1376 }
1377
1378 return res;
1379 }
1380
1381 static PyObject *
1382 Tkapp_Eval(PyObject *self, PyObject *args)
1383 {
1384 char *script;
1385 PyObject *res = NULL;
1386 int err;
1387
1388 if (!PyArg_ParseTuple(args, "s:eval", &script))
1389 return NULL;
1390
1391 CHECK_TCL_APPARTMENT;
1392
1393 ENTER_TCL
1394 err = Tcl_Eval(Tkapp_Interp(self), script);
1395 ENTER_OVERLAP
1396 if (err == TCL_ERROR)
1397 res = Tkinter_Error(self);
1398 else
1399 res = PyString_FromString(Tkapp_Result(self));
1400 LEAVE_OVERLAP_TCL
1401 return res;
1402 }
1403
1404 static PyObject *
1405 Tkapp_GlobalEval(PyObject *self, PyObject *args)
1406 {
1407 char *script;
1408 PyObject *res = NULL;
1409 int err;
1410
1411 if (!PyArg_ParseTuple(args, "s:globaleval", &script))
1412 return NULL;
1413
1414 CHECK_TCL_APPARTMENT;
1415
1416 ENTER_TCL
1417 err = Tcl_GlobalEval(Tkapp_Interp(self), script);
1418 ENTER_OVERLAP
1419 if (err == TCL_ERROR)
1420 res = Tkinter_Error(self);
1421 else
1422 res = PyString_FromString(Tkapp_Result(self));
1423 LEAVE_OVERLAP_TCL
1424 return res;
1425 }
1426
1427 static PyObject *
1428 Tkapp_EvalFile(PyObject *self, PyObject *args)
1429 {
1430 char *fileName;
1431 PyObject *res = NULL;
1432 int err;
1433
1434 if (!PyArg_ParseTuple(args, "s:evalfile", &fileName))
1435 return NULL;
1436
1437 CHECK_TCL_APPARTMENT;
1438
1439 ENTER_TCL
1440 err = Tcl_EvalFile(Tkapp_Interp(self), fileName);
1441 ENTER_OVERLAP
1442 if (err == TCL_ERROR)
1443 res = Tkinter_Error(self);
1444
1445 else
1446 res = PyString_FromString(Tkapp_Result(self));
1447 LEAVE_OVERLAP_TCL
1448 return res;
1449 }
1450
1451 static PyObject *
1452 Tkapp_Record(PyObject *self, PyObject *args)
1453 {
1454 char *script;
1455 PyObject *res = NULL;
1456 int err;
1457
1458 if (!PyArg_ParseTuple(args, "s", &script))
1459 return NULL;
1460
1461 CHECK_TCL_APPARTMENT;
1462
1463 ENTER_TCL
1464 err = Tcl_RecordAndEval(Tkapp_Interp(self), script, TCL_NO_EVAL);
1465 ENTER_OVERLAP
1466 if (err == TCL_ERROR)
1467 res = Tkinter_Error(self);
1468 else
1469 res = PyString_FromString(Tkapp_Result(self));
1470 LEAVE_OVERLAP_TCL
1471 return res;
1472 }
1473
1474 static PyObject *
1475 Tkapp_AddErrorInfo(PyObject *self, PyObject *args)
1476 {
1477 char *msg;
1478
1479 if (!PyArg_ParseTuple(args, "s:adderrorinfo", &msg))
1480 return NULL;
1481 CHECK_TCL_APPARTMENT;
1482
1483 ENTER_TCL
1484 Tcl_AddErrorInfo(Tkapp_Interp(self), msg);
1485 LEAVE_TCL
1486
1487 Py_INCREF(Py_None);
1488 return Py_None;
1489 }
1490
1491
1492 \f
1493 /** Tcl Variable **/
1494
1495 TCL_DECLARE_MUTEX(var_mutex)
1496
1497 typedef PyObject* (*EventFunc)(PyObject*, PyObject *args, int flags);
1498 typedef struct VarEvent {
1499 Tcl_Event ev; /* must be first */
1500 PyObject *self;
1501 PyObject *args;
1502 int flags;
1503 EventFunc func;
1504 PyObject **res;
1505 PyObject **exc_type;
1506 PyObject **exc_val;
1507 Tcl_Condition cond;
1508 } VarEvent;
1509
1510 static int
1511 varname_converter(PyObject *in, void *_out)
1512 {
1513 char **out = (char**)_out;
1514 if (PyString_Check(in)) {
1515 *out = PyString_AsString(in);
1516 return 1;
1517 }
1518 if (PyTclObject_Check(in)) {
1519 *out = PyTclObject_TclString(in);
1520 return 1;
1521 }
1522 /* XXX: Should give diagnostics. */
1523 return 0;
1524 }
1525
1526 static void
1527 var_perform(VarEvent *ev)
1528 {
1529 *(ev->res) = ev->func(ev->self, ev->args, ev->flags);
1530 if (!*(ev->res)) {
1531 PyObject *exc, *val, *tb;
1532 PyErr_Fetch(&exc, &val, &tb);
1533 PyErr_NormalizeException(&exc, &val, &tb);
1534 *(ev->exc_type) = exc;
1535 *(ev->exc_val) = val;
1536 Py_DECREF(tb);
1537 }
1538
1539 }
1540
1541 static int
1542 var_proc(VarEvent* ev, int flags)
1543 {
1544 ENTER_PYTHON
1545 var_perform(ev);
1546 Tcl_MutexLock(&var_mutex);
1547 Tcl_ConditionNotify(&ev->cond);
1548 Tcl_MutexUnlock(&var_mutex);
1549 LEAVE_PYTHON
1550 return 1;
1551 }
1552
1553 static PyObject*
1554 var_invoke(EventFunc func, PyObject *selfptr, PyObject *args, int flags)
1555 {
1556 TkappObject *self = (TkappObject*)selfptr;
1557 #ifdef WITH_THREAD
1558 if (self->threaded && self->thread_id != Tcl_GetCurrentThread()) {
1559 TkappObject *self = (TkappObject*)selfptr;
1560 VarEvent *ev;
1561 PyObject *res, *exc_type, *exc_val;
1562
1563 /* The current thread is not the interpreter thread. Marshal
1564 the call to the interpreter thread, then wait for
1565 completion. */
1566 if (!WaitForMainloop(self))
1567 return NULL;
1568
1569 ev = (VarEvent*)ckalloc(sizeof(VarEvent));
1570
1571 ev->self = selfptr;
1572 ev->args = args;
1573 ev->flags = flags;
1574 ev->func = func;
1575 ev->res = &res;
1576 ev->exc_type = &exc_type;
1577 ev->exc_val = &exc_val;
1578 ev->cond = NULL;
1579 ev->ev.proc = (Tcl_EventProc*)var_proc;
1580 Tkapp_ThreadSend(self, (Tcl_Event*)ev, &ev->cond, &var_mutex);
1581 if (!res) {
1582 PyErr_SetObject(exc_type, exc_val);
1583 Py_DECREF(exc_type);
1584 Py_DECREF(exc_val);
1585 return NULL;
1586 }
1587 return res;
1588 }
1589 #endif
1590 /* Tcl is not threaded, or this is the interpreter thread. */
1591 return func(selfptr, args, flags);
1592 }
1593
1594 static PyObject *
1595 SetVar(PyObject *self, PyObject *args, int flags)
1596 {
1597 char *name1, *name2;
1598 PyObject *newValue;
1599 PyObject *res = NULL;
1600 Tcl_Obj *newval, *ok;
1601
1602 if (PyArg_ParseTuple(args, "O&O:setvar",
1603 varname_converter, &name1, &newValue)) {
1604 /* XXX Acquire tcl lock??? */
1605 newval = AsObj(newValue);
1606 if (newval == NULL)
1607 return NULL;
1608 ENTER_TCL
1609 ok = Tcl_SetVar2Ex(Tkapp_Interp(self), name1, NULL,
1610 newval, flags);
1611 ENTER_OVERLAP
1612 if (!ok)
1613 Tkinter_Error(self);
1614 else {
1615 res = Py_None;
1616 Py_INCREF(res);
1617 }
1618 LEAVE_OVERLAP_TCL
1619 }
1620 else {
1621 PyErr_Clear();
1622 if (PyArg_ParseTuple(args, "ssO:setvar",
1623 &name1, &name2, &newValue)) {
1624 /* XXX must hold tcl lock already??? */
1625 newval = AsObj(newValue);
1626 ENTER_TCL
1627 ok = Tcl_SetVar2Ex(Tkapp_Interp(self), name1, name2, newval, flags);
1628 ENTER_OVERLAP
1629 if (!ok)
1630 Tkinter_Error(self);
1631 else {
1632 res = Py_None;
1633 Py_INCREF(res);
1634 }
1635 LEAVE_OVERLAP_TCL
1636 }
1637 else {
1638 return NULL;
1639 }
1640 }
1641 return res;
1642 }
1643
1644 static PyObject *
1645 Tkapp_SetVar(PyObject *self, PyObject *args)
1646 {
1647 return var_invoke(SetVar, self, args, TCL_LEAVE_ERR_MSG);
1648 }
1649
1650 static PyObject *
1651 Tkapp_GlobalSetVar(PyObject *self, PyObject *args)
1652 {
1653 return var_invoke(SetVar, self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
1654 }
1655
1656
1657 \f
1658 static PyObject *
1659 GetVar(PyObject *self, PyObject *args, int flags)
1660 {
1661 char *name1, *name2=NULL;
1662 PyObject *res = NULL;
1663 Tcl_Obj *tres;
1664
1665 if (!PyArg_ParseTuple(args, "O&|s:getvar",
1666 varname_converter, &name1, &name2))
1667 return NULL;
1668
1669 ENTER_TCL
1670 tres = Tcl_GetVar2Ex(Tkapp_Interp(self), name1, name2, flags);
1671 ENTER_OVERLAP
1672 if (tres == NULL) {
1673 PyErr_SetString(Tkinter_TclError, Tcl_GetStringResult(Tkapp_Interp(self)));
1674 } else {
1675 if (((TkappObject*)self)->wantobjects) {
1676 res = FromObj(self, tres);
1677 }
1678 else {
1679 res = PyString_FromString(Tcl_GetString(tres));
1680 }
1681 }
1682 LEAVE_OVERLAP_TCL
1683 return res;
1684 }
1685
1686 static PyObject *
1687 Tkapp_GetVar(PyObject *self, PyObject *args)
1688 {
1689 return var_invoke(GetVar, self, args, TCL_LEAVE_ERR_MSG);
1690 }
1691
1692 static PyObject *
1693 Tkapp_GlobalGetVar(PyObject *self, PyObject *args)
1694 {
1695 return var_invoke(GetVar, self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
1696 }
1697
1698
1699 \f
1700 static PyObject *
1701 UnsetVar(PyObject *self, PyObject *args, int flags)
1702 {
1703 char *name1, *name2=NULL;
1704 int code;
1705 PyObject *res = NULL;
1706
1707 if (!PyArg_ParseTuple(args, "s|s:unsetvar", &name1, &name2))
1708 return NULL;
1709
1710 ENTER_TCL
1711 code = Tcl_UnsetVar2(Tkapp_Interp(self), name1, name2, flags);
1712 ENTER_OVERLAP
1713 if (code == TCL_ERROR)
1714 res = Tkinter_Error(self);
1715 else {
1716 Py_INCREF(Py_None);
1717 res = Py_None;
1718 }
1719 LEAVE_OVERLAP_TCL
1720 return res;
1721 }
1722
1723 static PyObject *
1724 Tkapp_UnsetVar(PyObject *self, PyObject *args)
1725 {
1726 return var_invoke(UnsetVar, self, args, TCL_LEAVE_ERR_MSG);
1727 }
1728
1729 static PyObject *
1730 Tkapp_GlobalUnsetVar(PyObject *self, PyObject *args)
1731 {
1732 return var_invoke(UnsetVar, self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
1733 }
1734
1735
1736 \f
1737 /** Tcl to Python **/
1738
1739 static PyObject *
1740 Tkapp_GetInt(PyObject *self, PyObject *args)
1741 {
1742 char *s;
1743 int v;
1744
1745 if (PyTuple_Size(args) == 1) {
1746 PyObject* o = PyTuple_GetItem(args, 0);
1747 if (PyInt_Check(o)) {
1748 Py_INCREF(o);
1749 return o;
1750 }
1751 }
1752 if (!PyArg_ParseTuple(args, "s:getint", &s))
1753 return NULL;
1754 if (Tcl_GetInt(Tkapp_Interp(self), s, &v) == TCL_ERROR)
1755 return Tkinter_Error(self);
1756 return Py_BuildValue("i", v);
1757 }
1758
1759 static PyObject *
1760 Tkapp_GetDouble(PyObject *self, PyObject *args)
1761 {
1762 char *s;
1763 double v;
1764
1765 if (PyTuple_Size(args) == 1) {
1766 PyObject *o = PyTuple_GetItem(args, 0);
1767 if (PyFloat_Check(o)) {
1768 Py_INCREF(o);
1769 return o;
1770 }
1771 }
1772 if (!PyArg_ParseTuple(args, "s:getdouble", &s))
1773 return NULL;
1774 if (Tcl_GetDouble(Tkapp_Interp(self), s, &v) == TCL_ERROR)
1775 return Tkinter_Error(self);
1776 return Py_BuildValue("d", v);
1777 }
1778
1779 static PyObject *
1780 Tkapp_GetBoolean(PyObject *self, PyObject *args)
1781 {
1782 char *s;
1783 int v;
1784
1785 if (PyTuple_Size(args) == 1) {
1786 PyObject *o = PyTuple_GetItem(args, 0);
1787 if (PyInt_Check(o)) {
1788 Py_INCREF(o);
1789 return o;
1790 }
1791 }
1792 if (!PyArg_ParseTuple(args, "s:getboolean", &s))
1793 return NULL;
1794 if (Tcl_GetBoolean(Tkapp_Interp(self), s, &v) == TCL_ERROR)
1795 return Tkinter_Error(self);
1796 return PyBool_FromLong(v);
1797 }
1798
1799 static PyObject *
1800 Tkapp_ExprString(PyObject *self, PyObject *args)
1801 {
1802 char *s;
1803 PyObject *res = NULL;
1804 int retval;
1805
1806 if (!PyArg_ParseTuple(args, "s:exprstring", &s))
1807 return NULL;
1808
1809 CHECK_TCL_APPARTMENT;
1810
1811 ENTER_TCL
1812 retval = Tcl_ExprString(Tkapp_Interp(self), s);
1813 ENTER_OVERLAP
1814 if (retval == TCL_ERROR)
1815 res = Tkinter_Error(self);
1816 else
1817 res = Py_BuildValue("s", Tkapp_Result(self));
1818 LEAVE_OVERLAP_TCL
1819 return res;
1820 }
1821
1822 static PyObject *
1823 Tkapp_ExprLong(PyObject *self, PyObject *args)
1824 {
1825 char *s;
1826 PyObject *res = NULL;
1827 int retval;
1828 long v;
1829
1830 if (!PyArg_ParseTuple(args, "s:exprlong", &s))
1831 return NULL;
1832
1833 CHECK_TCL_APPARTMENT;
1834
1835 ENTER_TCL
1836 retval = Tcl_ExprLong(Tkapp_Interp(self), s, &v);
1837 ENTER_OVERLAP
1838 if (retval == TCL_ERROR)
1839 res = Tkinter_Error(self);
1840 else
1841 res = Py_BuildValue("l", v);
1842 LEAVE_OVERLAP_TCL
1843 return res;
1844 }
1845
1846 static PyObject *
1847 Tkapp_ExprDouble(PyObject *self, PyObject *args)
1848 {
1849 char *s;
1850 PyObject *res = NULL;
1851 double v;
1852 int retval;
1853
1854 if (!PyArg_ParseTuple(args, "s:exprdouble", &s))
1855 return NULL;
1856 CHECK_TCL_APPARTMENT;
1857 PyFPE_START_PROTECT("Tkapp_ExprDouble", return 0)
1858 ENTER_TCL
1859 retval = Tcl_ExprDouble(Tkapp_Interp(self), s, &v);
1860 ENTER_OVERLAP
1861 PyFPE_END_PROTECT(retval)
1862 if (retval == TCL_ERROR)
1863 res = Tkinter_Error(self);
1864 else
1865 res = Py_BuildValue("d", v);
1866 LEAVE_OVERLAP_TCL
1867 return res;
1868 }
1869
1870 static PyObject *
1871 Tkapp_ExprBoolean(PyObject *self, PyObject *args)
1872 {
1873 char *s;
1874 PyObject *res = NULL;
1875 int retval;
1876 int v;
1877
1878 if (!PyArg_ParseTuple(args, "s:exprboolean", &s))
1879 return NULL;
1880 CHECK_TCL_APPARTMENT;
1881 ENTER_TCL
1882 retval = Tcl_ExprBoolean(Tkapp_Interp(self), s, &v);
1883 ENTER_OVERLAP
1884 if (retval == TCL_ERROR)
1885 res = Tkinter_Error(self);
1886 else
1887 res = Py_BuildValue("i", v);
1888 LEAVE_OVERLAP_TCL
1889 return res;
1890 }
1891
1892
1893 \f
1894 static PyObject *
1895 Tkapp_SplitList(PyObject *self, PyObject *args)
1896 {
1897 char *list;
1898 int argc;
1899 char **argv;
1900 PyObject *v;
1901 int i;
1902
1903 if (PyTuple_Size(args) == 1) {
1904 v = PyTuple_GetItem(args, 0);
1905 if (PyTuple_Check(v)) {
1906 Py_INCREF(v);
1907 return v;
1908 }
1909 }
1910 if (!PyArg_ParseTuple(args, "et:splitlist", "utf-8", &list))
1911 return NULL;
1912
1913 if (Tcl_SplitList(Tkapp_Interp(self), list,
1914 &argc, &argv) == TCL_ERROR) {
1915 PyMem_Free(list);
1916 return Tkinter_Error(self);
1917 }
1918
1919 if (!(v = PyTuple_New(argc)))
1920 goto finally;
1921
1922 for (i = 0; i < argc; i++) {
1923 PyObject *s = PyString_FromString(argv[i]);
1924 if (!s || PyTuple_SetItem(v, i, s)) {
1925 Py_DECREF(v);
1926 v = NULL;
1927 goto finally;
1928 }
1929 }
1930
1931 finally:
1932 ckfree(FREECAST argv);
1933 PyMem_Free(list);
1934 return v;
1935 }
1936
1937 static PyObject *
1938 Tkapp_Split(PyObject *self, PyObject *args)
1939 {
1940 PyObject *v;
1941 char *list;
1942
1943 if (PyTuple_Size(args) == 1) {
1944 PyObject* o = PyTuple_GetItem(args, 0);
1945 if (PyTuple_Check(o)) {
1946 o = SplitObj(o);
1947 return o;
1948 }
1949 }
1950 if (!PyArg_ParseTuple(args, "et:split", "utf-8", &list))
1951 return NULL;
1952 v = Split(list);
1953 PyMem_Free(list);
1954 return v;
1955 }
1956
1957 static PyObject *
1958 Tkapp_Merge(PyObject *self, PyObject *args)
1959 {
1960 char *s = Merge(args);
1961 PyObject *res = NULL;
1962
1963 if (s) {
1964 res = PyString_FromString(s);
1965 ckfree(s);
1966 }
1967
1968 return res;
1969 }
1970
1971
1972 \f
1973 /** Tcl Command **/
1974
1975 /* Client data struct */
1976 typedef struct {
1977 PyObject *self;
1978 PyObject *func;
1979 } PythonCmd_ClientData;
1980
1981 static int
1982 PythonCmd_Error(Tcl_Interp *interp)
1983 {
1984 errorInCmd = 1;
1985 PyErr_Fetch(&excInCmd, &valInCmd, &trbInCmd);
1986 LEAVE_PYTHON
1987 return TCL_ERROR;
1988 }
1989
1990 /* This is the Tcl command that acts as a wrapper for Python
1991 * function or method.
1992 */
1993 static int
1994 PythonCmd(ClientData clientData, Tcl_Interp *interp, int argc, char *argv[])
1995 {
1996 PythonCmd_ClientData *data = (PythonCmd_ClientData *)clientData;
1997 PyObject *self, *func, *arg, *res;
1998 int i, rv;
1999 Tcl_Obj *obj_res;
2000
2001 ENTER_PYTHON
2002
2003 /* TBD: no error checking here since we know, via the
2004 * Tkapp_CreateCommand() that the client data is a two-tuple
2005 */
2006 self = data->self;
2007 func = data->func;
2008
2009 /* Create argument list (argv1, ..., argvN) */
2010 if (!(arg = PyTuple_New(argc - 1)))
2011 return PythonCmd_Error(interp);
2012
2013 for (i = 0; i < (argc - 1); i++) {
2014 PyObject *s = PyString_FromString(argv[i + 1]);
2015 if (!s || PyTuple_SetItem(arg, i, s)) {
2016 Py_DECREF(arg);
2017 return PythonCmd_Error(interp);
2018 }
2019 }
2020 res = PyEval_CallObject(func, arg);
2021 Py_DECREF(arg);
2022
2023 if (res == NULL)
2024 return PythonCmd_Error(interp);
2025
2026 obj_res = AsObj(res);
2027 if (obj_res == NULL) {
2028 Py_DECREF(res);
2029 return PythonCmd_Error(interp);
2030 }
2031 else {
2032 Tcl_SetObjResult(Tkapp_Interp(self), obj_res);
2033 rv = TCL_OK;
2034 }
2035
2036 Py_DECREF(res);
2037
2038 LEAVE_PYTHON
2039
2040 return rv;
2041 }
2042
2043 static void
2044 PythonCmdDelete(ClientData clientData)
2045 {
2046 PythonCmd_ClientData *data = (PythonCmd_ClientData *)clientData;
2047
2048 ENTER_PYTHON
2049 Py_XDECREF(data->self);
2050 Py_XDECREF(data->func);
2051 PyMem_DEL(data);
2052 LEAVE_PYTHON
2053 }
2054
2055
2056 \f
2057
2058 TCL_DECLARE_MUTEX(command_mutex)
2059
2060 typedef struct CommandEvent{
2061 Tcl_Event ev;
2062 Tcl_Interp* interp;
2063 char *name;
2064 int create;
2065 int *status;
2066 ClientData *data;
2067 Tcl_Condition done;
2068 } CommandEvent;
2069
2070 static int
2071 Tkapp_CommandProc(CommandEvent *ev, int flags)
2072 {
2073 if (ev->create)
2074 *ev->status = Tcl_CreateCommand(
2075 ev->interp, ev->name, PythonCmd,
2076 ev->data, PythonCmdDelete) == NULL;
2077 else
2078 *ev->status = Tcl_DeleteCommand(ev->interp, ev->name);
2079 Tcl_MutexLock(&command_mutex);
2080 Tcl_ConditionNotify(&ev->done);
2081 Tcl_MutexUnlock(&command_mutex);
2082 return 1;
2083 }
2084
2085 static PyObject *
2086 Tkapp_CreateCommand(PyObject *selfptr, PyObject *args)
2087 {
2088 TkappObject *self = (TkappObject*)selfptr;
2089 PythonCmd_ClientData *data;
2090 char *cmdName;
2091 PyObject *func;
2092 int err;
2093
2094 if (!PyArg_ParseTuple(args, "sO:createcommand", &cmdName, &func))
2095 return NULL;
2096 if (!PyCallable_Check(func)) {
2097 PyErr_SetString(PyExc_TypeError, "command not callable");
2098 return NULL;
2099 }
2100
2101 #ifdef WITH_THREAD
2102 if (self->threaded && self->thread_id != Tcl_GetCurrentThread() &&
2103 !WaitForMainloop(self))
2104 return NULL;
2105 #endif
2106
2107 data = PyMem_NEW(PythonCmd_ClientData, 1);
2108 if (!data)
2109 return PyErr_NoMemory();
2110 Py_INCREF(self);
2111 Py_INCREF(func);
2112 data->self = selfptr;
2113 data->func = func;
2114
2115 if (self->threaded && self->thread_id != Tcl_GetCurrentThread()) {
2116 CommandEvent *ev = (CommandEvent*)ckalloc(sizeof(CommandEvent));
2117 ev->ev.proc = (Tcl_EventProc*)Tkapp_CommandProc;
2118 ev->interp = self->interp;
2119 ev->create = 1;
2120 ev->name = cmdName;
2121 ev->data = (ClientData)data;
2122 ev->status = &err;
2123 ev->done = NULL;
2124 Tkapp_ThreadSend(self, (Tcl_Event*)ev, &ev->done, &command_mutex);
2125 }
2126 else {
2127 ENTER_TCL
2128 err = Tcl_CreateCommand(
2129 Tkapp_Interp(self), cmdName, PythonCmd,
2130 (ClientData)data, PythonCmdDelete) == NULL;
2131 LEAVE_TCL
2132 }
2133 if (err) {
2134 PyErr_SetString(Tkinter_TclError, "can't create Tcl command");
2135 PyMem_DEL(data);
2136 return NULL;
2137 }
2138
2139 Py_INCREF(Py_None);
2140 return Py_None;
2141 }
2142
2143
2144 \f
2145 static PyObject *
2146 Tkapp_DeleteCommand(PyObject *selfptr, PyObject *args)
2147 {
2148 TkappObject *self = (TkappObject*)selfptr;
2149 char *cmdName;
2150 int err;
2151
2152 if (!PyArg_ParseTuple(args, "s:deletecommand", &cmdName))
2153 return NULL;
2154 if (self->threaded && self->thread_id != Tcl_GetCurrentThread()) {
2155 CommandEvent *ev;
2156 ev = (CommandEvent*)ckalloc(sizeof(CommandEvent));
2157 ev->ev.proc = (Tcl_EventProc*)Tkapp_CommandProc;
2158 ev->interp = self->interp;
2159 ev->create = 0;
2160 ev->name = cmdName;
2161 ev->status = &err;
2162 ev->done = NULL;
2163 Tkapp_ThreadSend(self, (Tcl_Event*)ev, &ev->done,
2164 &command_mutex);
2165 }
2166 else {
2167 ENTER_TCL
2168 err = Tcl_DeleteCommand(self->interp, cmdName);
2169 LEAVE_TCL
2170 }
2171 if (err == -1) {
2172 PyErr_SetString(Tkinter_TclError, "can't delete Tcl command");
2173 return NULL;
2174 }
2175 Py_INCREF(Py_None);
2176 return Py_None;
2177 }
2178
2179
2180 \f
2181 #ifdef HAVE_CREATEFILEHANDLER
2182 /** File Handler **/
2183
2184 typedef struct _fhcdata {
2185 PyObject *func;
2186 PyObject *file;
2187 int id;
2188 struct _fhcdata *next;
2189 } FileHandler_ClientData;
2190
2191 static FileHandler_ClientData *HeadFHCD;
2192
2193 static FileHandler_ClientData *
2194 NewFHCD(PyObject *func, PyObject *file, int id)
2195 {
2196 FileHandler_ClientData *p;
2197 p = PyMem_NEW(FileHandler_ClientData, 1);
2198 if (p != NULL) {
2199 Py_XINCREF(func);
2200 Py_XINCREF(file);
2201 p->func = func;
2202 p->file = file;
2203 p->id = id;
2204 p->next = HeadFHCD;
2205 HeadFHCD = p;
2206 }
2207 return p;
2208 }
2209
2210 static void
2211 DeleteFHCD(int id)
2212 {
2213 FileHandler_ClientData *p, **pp;
2214
2215 pp = &HeadFHCD;
2216 while ((p = *pp) != NULL) {
2217 if (p->id == id) {
2218 *pp = p->next;
2219 Py_XDECREF(p->func);
2220 Py_XDECREF(p->file);
2221 PyMem_DEL(p);
2222 }
2223 else
2224 pp = &p->next;
2225 }
2226 }
2227
2228 static void
2229 FileHandler(ClientData clientData, int mask)
2230 {
2231 FileHandler_ClientData *data = (FileHandler_ClientData *)clientData;
2232 PyObject *func, *file, *arg, *res;
2233
2234 ENTER_PYTHON
2235 func = data->func;
2236 file = data->file;
2237
2238 arg = Py_BuildValue("(Oi)", file, (long) mask);
2239 res = PyEval_CallObject(func, arg);
2240 Py_DECREF(arg);
2241
2242 if (res == NULL) {
2243 errorInCmd = 1;
2244 PyErr_Fetch(&excInCmd, &valInCmd, &trbInCmd);
2245 }
2246 Py_XDECREF(res);
2247 LEAVE_PYTHON
2248 }
2249
2250 static PyObject *
2251 Tkapp_CreateFileHandler(PyObject *self, PyObject *args)
2252 /* args is (file, mask, func) */
2253 {
2254 FileHandler_ClientData *data;
2255 PyObject *file, *func;
2256 int mask, tfile;
2257
2258 if (!self && Py_Py3kWarningFlag) {
2259 if (PyErr_Warn(PyExc_DeprecationWarning,
2260 "_tkinter.createfilehandler is gone in 3.x") < 0)
2261 return NULL;
2262 }
2263
2264 if (!PyArg_ParseTuple(args, "OiO:createfilehandler",
2265 &file, &mask, &func))
2266 return NULL;
2267
2268 #ifdef WITH_THREAD
2269 if (!self && !tcl_lock) {
2270 /* We don't have the Tcl lock since Tcl is threaded. */
2271 PyErr_SetString(PyExc_RuntimeError,
2272 "_tkinter.createfilehandler not supported "
2273 "for threaded Tcl");
2274 return NULL;
2275 }
2276 #endif
2277
2278 if (self) {
2279 CHECK_TCL_APPARTMENT;
2280 }
2281
2282 tfile = PyObject_AsFileDescriptor(file);
2283 if (tfile < 0)
2284 return NULL;
2285 if (!PyCallable_Check(func)) {
2286 PyErr_SetString(PyExc_TypeError, "bad argument list");
2287 return NULL;
2288 }
2289
2290 data = NewFHCD(func, file, tfile);
2291 if (data == NULL)
2292 return NULL;
2293
2294 /* Ought to check for null Tcl_File object... */
2295 ENTER_TCL
2296 Tcl_CreateFileHandler(tfile, mask, FileHandler, (ClientData) data);
2297 LEAVE_TCL
2298 Py_INCREF(Py_None);
2299 return Py_None;
2300 }
2301
2302 static PyObject *
2303 Tkapp_DeleteFileHandler(PyObject *self, PyObject *args)
2304 {
2305 PyObject *file;
2306 int tfile;
2307
2308 if (!self && Py_Py3kWarningFlag) {
2309 if (PyErr_Warn(PyExc_DeprecationWarning,
2310 "_tkinter.deletefilehandler is gone in 3.x") < 0)
2311 return NULL;
2312 }
2313
2314 if (!PyArg_ParseTuple(args, "O:deletefilehandler", &file))
2315 return NULL;
2316
2317 #ifdef WITH_THREAD
2318 if (!self && !tcl_lock) {
2319 /* We don't have the Tcl lock since Tcl is threaded. */
2320 PyErr_SetString(PyExc_RuntimeError,
2321 "_tkinter.deletefilehandler not supported "
2322 "for threaded Tcl");
2323 return NULL;
2324 }
2325 #endif
2326
2327 if (self) {
2328 CHECK_TCL_APPARTMENT;
2329 }
2330
2331 tfile = PyObject_AsFileDescriptor(file);
2332 if (tfile < 0)
2333 return NULL;
2334
2335 DeleteFHCD(tfile);
2336
2337 /* Ought to check for null Tcl_File object... */
2338 ENTER_TCL
2339 Tcl_DeleteFileHandler(tfile);
2340 LEAVE_TCL
2341 Py_INCREF(Py_None);
2342 return Py_None;
2343 }
2344 #endif /* HAVE_CREATEFILEHANDLER */
2345
2346 \f
2347 /**** Tktt Object (timer token) ****/
2348
2349 static PyTypeObject Tktt_Type;
2350
2351 typedef struct {
2352 PyObject_HEAD
2353 Tcl_TimerToken token;
2354 PyObject *func;
2355 } TkttObject;
2356
2357 static PyObject *
2358 Tktt_DeleteTimerHandler(PyObject *self, PyObject *args)
2359 {
2360 TkttObject *v = (TkttObject *)self;
2361 PyObject *func = v->func;
2362
2363 if (!PyArg_ParseTuple(args, ":deletetimerhandler"))
2364 return NULL;
2365 if (v->token != NULL) {
2366 Tcl_DeleteTimerHandler(v->token);
2367 v->token = NULL;
2368 }
2369 if (func != NULL) {
2370 v->func = NULL;
2371 Py_DECREF(func);
2372 Py_DECREF(v); /* See Tktt_New() */
2373 }
2374 Py_INCREF(Py_None);
2375 return Py_None;
2376 }
2377
2378 static PyMethodDef Tktt_methods[] =
2379 {
2380 {"deletetimerhandler", Tktt_DeleteTimerHandler, METH_VARARGS},
2381 {NULL, NULL}
2382 };
2383
2384 static TkttObject *
2385 Tktt_New(PyObject *func)
2386 {
2387 TkttObject *v;
2388
2389 v = PyObject_New(TkttObject, &Tktt_Type);
2390 if (v == NULL)
2391 return NULL;
2392
2393 Py_INCREF(func);
2394 v->token = NULL;
2395 v->func = func;
2396
2397 /* Extra reference, deleted when called or when handler is deleted */
2398 Py_INCREF(v);
2399 return v;
2400 }
2401
2402 static void
2403 Tktt_Dealloc(PyObject *self)
2404 {
2405 TkttObject *v = (TkttObject *)self;
2406 PyObject *func = v->func;
2407
2408 Py_XDECREF(func);
2409
2410 PyObject_Del(self);
2411 }
2412
2413 static PyObject *
2414 Tktt_Repr(PyObject *self)
2415 {
2416 TkttObject *v = (TkttObject *)self;
2417 char buf[100];
2418
2419 PyOS_snprintf(buf, sizeof(buf), "<tktimertoken at %p%s>", v,
2420 v->func == NULL ? ", handler deleted" : "");
2421 return PyString_FromString(buf);
2422 }
2423
2424 static PyObject *
2425 Tktt_GetAttr(PyObject *self, char *name)
2426 {
2427 return Py_FindMethod(Tktt_methods, self, name);
2428 }
2429
2430 static PyTypeObject Tktt_Type =
2431 {
2432 PyVarObject_HEAD_INIT(NULL, 0)
2433 "tktimertoken", /*tp_name */
2434 sizeof(TkttObject), /*tp_basicsize */
2435 0, /*tp_itemsize */
2436 Tktt_Dealloc, /*tp_dealloc */
2437 0, /*tp_print */
2438 Tktt_GetAttr, /*tp_getattr */
2439 0, /*tp_setattr */
2440 0, /*tp_compare */
2441 Tktt_Repr, /*tp_repr */
2442 0, /*tp_as_number */
2443 0, /*tp_as_sequence */
2444 0, /*tp_as_mapping */
2445 0, /*tp_hash */
2446 };
2447
2448
2449 \f
2450 /** Timer Handler **/
2451
2452 static void
2453 TimerHandler(ClientData clientData)
2454 {
2455 TkttObject *v = (TkttObject *)clientData;
2456 PyObject *func = v->func;
2457 PyObject *res;
2458
2459 if (func == NULL)
2460 return;
2461
2462 v->func = NULL;
2463
2464 ENTER_PYTHON
2465
2466 res = PyEval_CallObject(func, NULL);
2467 Py_DECREF(func);
2468 Py_DECREF(v); /* See Tktt_New() */
2469
2470 if (res == NULL) {
2471 errorInCmd = 1;
2472 PyErr_Fetch(&excInCmd, &valInCmd, &trbInCmd);
2473 }
2474 else
2475 Py_DECREF(res);
2476
2477 LEAVE_PYTHON
2478 }
2479
2480 static PyObject *
2481 Tkapp_CreateTimerHandler(PyObject *self, PyObject *args)
2482 {
2483 int milliseconds;
2484 PyObject *func;
2485 TkttObject *v;
2486
2487 if (!self && Py_Py3kWarningFlag) {
2488 if (PyErr_Warn(PyExc_DeprecationWarning,
2489 "_tkinter.createtimerhandler is gone in 3.x") < 0)
2490 return NULL;
2491 }
2492
2493 if (!PyArg_ParseTuple(args, "iO:createtimerhandler",
2494 &milliseconds, &func))
2495 return NULL;
2496 if (!PyCallable_Check(func)) {
2497 PyErr_SetString(PyExc_TypeError, "bad argument list");
2498 return NULL;
2499 }
2500
2501 #ifdef WITH_THREAD
2502 if (!self && !tcl_lock) {
2503 /* We don't have the Tcl lock since Tcl is threaded. */
2504 PyErr_SetString(PyExc_RuntimeError,
2505 "_tkinter.createtimerhandler not supported "
2506 "for threaded Tcl");
2507 return NULL;
2508 }
2509 #endif
2510
2511 if (self) {
2512 CHECK_TCL_APPARTMENT;
2513 }
2514
2515 v = Tktt_New(func);
2516 if (v) {
2517 v->token = Tcl_CreateTimerHandler(milliseconds, TimerHandler,
2518 (ClientData)v);
2519 }
2520
2521 return (PyObject *) v;
2522 }
2523
2524 \f
2525 /** Event Loop **/
2526
2527 static PyObject *
2528 Tkapp_MainLoop(PyObject *selfptr, PyObject *args)
2529 {
2530 int threshold = 0;
2531 TkappObject *self = (TkappObject*)selfptr;
2532 #ifdef WITH_THREAD
2533 PyThreadState *tstate = PyThreadState_Get();
2534 #endif
2535
2536 if (!self && Py_Py3kWarningFlag) {
2537 if (PyErr_Warn(PyExc_DeprecationWarning,
2538 "_tkinter.mainloop is gone in 3.x") < 0)
2539 return NULL;
2540 }
2541
2542 if (!PyArg_ParseTuple(args, "|i:mainloop", &threshold))
2543 return NULL;
2544
2545 #ifdef WITH_THREAD
2546 if (!self && !tcl_lock) {
2547 /* We don't have the Tcl lock since Tcl is threaded. */
2548 PyErr_SetString(PyExc_RuntimeError,
2549 "_tkinter.mainloop not supported "
2550 "for threaded Tcl");
2551 return NULL;
2552 }
2553 #endif
2554
2555 if (self) {
2556 CHECK_TCL_APPARTMENT;
2557 self->dispatching = 1;
2558 }
2559
2560 quitMainLoop = 0;
2561 while (Tk_GetNumMainWindows() > threshold &&
2562 !quitMainLoop &&
2563 !errorInCmd)
2564 {
2565 int result;
2566
2567 #ifdef WITH_THREAD
2568 if (self && self->threaded) {
2569 /* Allow other Python threads to run. */
2570 ENTER_TCL
2571 result = Tcl_DoOneEvent(0);
2572 LEAVE_TCL
2573 }
2574 else {
2575 Py_BEGIN_ALLOW_THREADS
2576 if(tcl_lock)PyThread_acquire_lock(tcl_lock, 1);
2577 tcl_tstate = tstate;
2578 result = Tcl_DoOneEvent(TCL_DONT_WAIT);
2579 tcl_tstate = NULL;
2580 if(tcl_lock)PyThread_release_lock(tcl_lock);
2581 if (result == 0)
2582 Sleep(Tkinter_busywaitinterval);
2583 Py_END_ALLOW_THREADS
2584 }
2585 #else
2586 result = Tcl_DoOneEvent(0);
2587 #endif
2588
2589 if (PyErr_CheckSignals() != 0) {
2590 if (self)
2591 self->dispatching = 0;
2592 return NULL;
2593 }
2594 if (result < 0)
2595 break;
2596 }
2597 if (self)
2598 self->dispatching = 0;
2599 quitMainLoop = 0;
2600
2601 if (errorInCmd) {
2602 errorInCmd = 0;
2603 PyErr_Restore(excInCmd, valInCmd, trbInCmd);
2604 excInCmd = valInCmd = trbInCmd = NULL;
2605 return NULL;
2606 }
2607 Py_INCREF(Py_None);
2608 return Py_None;
2609 }
2610
2611 static PyObject *
2612 Tkapp_DoOneEvent(PyObject *self, PyObject *args)
2613 {
2614 int flags = 0;
2615 int rv;
2616
2617 if (!self && Py_Py3kWarningFlag) {
2618 if (PyErr_Warn(PyExc_DeprecationWarning,
2619 "_tkinter.dooneevent is gone in 3.x") < 0)
2620 return NULL;
2621 }
2622
2623 if (!PyArg_ParseTuple(args, "|i:dooneevent", &flags))
2624 return NULL;
2625
2626 ENTER_TCL
2627 rv = Tcl_DoOneEvent(flags);
2628 LEAVE_TCL
2629 return Py_BuildValue("i", rv);
2630 }
2631
2632 static PyObject *
2633 Tkapp_Quit(PyObject *self, PyObject *args)
2634 {
2635
2636 if (!self && Py_Py3kWarningFlag) {
2637 if (PyErr_Warn(PyExc_DeprecationWarning,
2638 "_tkinter.createfilehandler is gone in 3.x") < 0)
2639 return NULL;
2640 }
2641
2642 if (!PyArg_ParseTuple(args, ":quit"))
2643 return NULL;
2644
2645 quitMainLoop = 1;
2646 Py_INCREF(Py_None);
2647 return Py_None;
2648 }
2649
2650 static PyObject *
2651 Tkapp_InterpAddr(PyObject *self, PyObject *args)
2652 {
2653
2654 if (!PyArg_ParseTuple(args, ":interpaddr"))
2655 return NULL;
2656
2657 return PyInt_FromLong((long)Tkapp_Interp(self));
2658 }
2659
2660 static PyObject *
2661 Tkapp_TkInit(PyObject *self, PyObject *args)
2662 {
2663 static int has_failed;
2664 Tcl_Interp *interp = Tkapp_Interp(self);
2665 Tk_Window main_window;
2666 const char * _tk_exists = NULL;
2667 int err;
2668 main_window = Tk_MainWindow(interp);
2669
2670 /* In all current versions of Tk (including 8.4.13), Tk_Init
2671 deadlocks on the second call when the first call failed.
2672 To avoid the deadlock, we just refuse the second call through
2673 a static variable. */
2674 if (has_failed) {
2675 PyErr_SetString(Tkinter_TclError,
2676 "Calling Tk_Init again after a previous call failed might deadlock");
2677 return NULL;
2678 }
2679
2680 /* We want to guard against calling Tk_Init() multiple times */
2681 CHECK_TCL_APPARTMENT;
2682 ENTER_TCL
2683 err = Tcl_Eval(Tkapp_Interp(self), "info exists tk_version");
2684 ENTER_OVERLAP
2685 if (err == TCL_ERROR) {
2686 /* This sets an exception, but we cannot return right
2687 away because we need to exit the overlap first. */
2688 Tkinter_Error(self);
2689 } else {
2690 _tk_exists = Tkapp_Result(self);
2691 }
2692 LEAVE_OVERLAP_TCL
2693 if (err == TCL_ERROR) {
2694 return NULL;
2695 }
2696 if (_tk_exists == NULL || strcmp(_tk_exists, "1") != 0) {
2697 if (Tk_Init(interp) == TCL_ERROR) {
2698 PyErr_SetString(Tkinter_TclError, Tcl_GetStringResult(Tkapp_Interp(self)));
2699 has_failed = 1;
2700 return NULL;
2701 }
2702 }
2703 Py_INCREF(Py_None);
2704 return Py_None;
2705 }
2706
2707 static PyObject *
2708 Tkapp_WantObjects(PyObject *self, PyObject *args)
2709 {
2710
2711 int wantobjects = -1;
2712 if (!PyArg_ParseTuple(args, "|i:wantobjects", &wantobjects))
2713 return NULL;
2714 if (wantobjects == -1)
2715 return PyBool_FromLong(((TkappObject*)self)->wantobjects);
2716 ((TkappObject*)self)->wantobjects = wantobjects;
2717
2718 Py_INCREF(Py_None);
2719 return Py_None;
2720 }
2721
2722 static PyObject *
2723 Tkapp_WillDispatch(PyObject *self, PyObject *args)
2724 {
2725
2726 ((TkappObject*)self)->dispatching = 1;
2727
2728 Py_INCREF(Py_None);
2729 return Py_None;
2730 }
2731
2732 \f
2733 /**** Tkapp Method List ****/
2734
2735 static PyMethodDef Tkapp_methods[] =
2736 {
2737 {"willdispatch", Tkapp_WillDispatch, METH_NOARGS},
2738 {"wantobjects", Tkapp_WantObjects, METH_VARARGS},
2739 {"call", Tkapp_Call, METH_VARARGS},
2740 {"globalcall", Tkapp_GlobalCall, METH_VARARGS},
2741 {"eval", Tkapp_Eval, METH_VARARGS},
2742 {"globaleval", Tkapp_GlobalEval, METH_VARARGS},
2743 {"evalfile", Tkapp_EvalFile, METH_VARARGS},
2744 {"record", Tkapp_Record, METH_VARARGS},
2745 {"adderrorinfo", Tkapp_AddErrorInfo, METH_VARARGS},
2746 {"setvar", Tkapp_SetVar, METH_VARARGS},
2747 {"globalsetvar", Tkapp_GlobalSetVar, METH_VARARGS},
2748 {"getvar", Tkapp_GetVar, METH_VARARGS},
2749 {"globalgetvar", Tkapp_GlobalGetVar, METH_VARARGS},
2750 {"unsetvar", Tkapp_UnsetVar, METH_VARARGS},
2751 {"globalunsetvar", Tkapp_GlobalUnsetVar, METH_VARARGS},
2752 {"getint", Tkapp_GetInt, METH_VARARGS},
2753 {"getdouble", Tkapp_GetDouble, METH_VARARGS},
2754 {"getboolean", Tkapp_GetBoolean, METH_VARARGS},
2755 {"exprstring", Tkapp_ExprString, METH_VARARGS},
2756 {"exprlong", Tkapp_ExprLong, METH_VARARGS},
2757 {"exprdouble", Tkapp_ExprDouble, METH_VARARGS},
2758 {"exprboolean", Tkapp_ExprBoolean, METH_VARARGS},
2759 {"splitlist", Tkapp_SplitList, METH_VARARGS},
2760 {"split", Tkapp_Split, METH_VARARGS},
2761 {"merge", Tkapp_Merge, METH_VARARGS},
2762 {"createcommand", Tkapp_CreateCommand, METH_VARARGS},
2763 {"deletecommand", Tkapp_DeleteCommand, METH_VARARGS},
2764 #ifdef HAVE_CREATEFILEHANDLER
2765 {"createfilehandler", Tkapp_CreateFileHandler, METH_VARARGS},
2766 {"deletefilehandler", Tkapp_DeleteFileHandler, METH_VARARGS},
2767 #endif
2768 {"createtimerhandler", Tkapp_CreateTimerHandler, METH_VARARGS},
2769 {"mainloop", Tkapp_MainLoop, METH_VARARGS},
2770 {"dooneevent", Tkapp_DoOneEvent, METH_VARARGS},
2771 {"quit", Tkapp_Quit, METH_VARARGS},
2772 {"interpaddr", Tkapp_InterpAddr, METH_VARARGS},
2773 {"loadtk", Tkapp_TkInit, METH_NOARGS},
2774 {NULL, NULL}
2775 };
2776
2777
2778 \f
2779 /**** Tkapp Type Methods ****/
2780
2781 static void
2782 Tkapp_Dealloc(PyObject *self)
2783 {
2784 /*CHECK_TCL_APPARTMENT;*/
2785 ENTER_TCL
2786 Tcl_DeleteInterp(Tkapp_Interp(self));
2787 LEAVE_TCL
2788 PyObject_Del(self);
2789 DisableEventHook();
2790 }
2791
2792 static PyObject *
2793 Tkapp_GetAttr(PyObject *self, char *name)
2794 {
2795 return Py_FindMethod(Tkapp_methods, self, name);
2796 }
2797
2798 static PyTypeObject Tkapp_Type =
2799 {
2800 PyVarObject_HEAD_INIT(NULL, 0)
2801 "tkapp", /*tp_name */
2802 sizeof(TkappObject), /*tp_basicsize */
2803 0, /*tp_itemsize */
2804 Tkapp_Dealloc, /*tp_dealloc */
2805 0, /*tp_print */
2806 Tkapp_GetAttr, /*tp_getattr */
2807 0, /*tp_setattr */
2808 0, /*tp_compare */
2809 0, /*tp_repr */
2810 0, /*tp_as_number */
2811 0, /*tp_as_sequence */
2812 0, /*tp_as_mapping */
2813 0, /*tp_hash */
2814 };
2815
2816
2817 \f
2818 /**** Tkinter Module ****/
2819
2820 typedef struct {
2821 PyObject* tuple;
2822 int size; /* current size */
2823 int maxsize; /* allocated size */
2824 } FlattenContext;
2825
2826 static int
2827 _bump(FlattenContext* context, int size)
2828 {
2829 /* expand tuple to hold (at least) size new items.
2830 return true if successful, false if an exception was raised */
2831
2832 int maxsize = context->maxsize * 2;
2833
2834 if (maxsize < context->size + size)
2835 maxsize = context->size + size;
2836
2837 context->maxsize = maxsize;
2838
2839 return _PyTuple_Resize(&context->tuple, maxsize) >= 0;
2840 }
2841
2842 static int
2843 _flatten1(FlattenContext* context, PyObject* item, int depth)
2844 {
2845 /* add tuple or list to argument tuple (recursively) */
2846
2847 int i, size;
2848
2849 if (depth > 1000) {
2850 PyErr_SetString(PyExc_ValueError,
2851 "nesting too deep in _flatten");
2852 return 0;
2853 } else if (PyList_Check(item)) {
2854 size = PyList_GET_SIZE(item);
2855 /* preallocate (assume no nesting) */
2856 if (context->size + size > context->maxsize &&
2857 !_bump(context, size))
2858 return 0;
2859 /* copy items to output tuple */
2860 for (i = 0; i < size; i++) {
2861 PyObject *o = PyList_GET_ITEM(item, i);
2862 if (PyList_Check(o) || PyTuple_Check(o)) {
2863 if (!_flatten1(context, o, depth + 1))
2864 return 0;
2865 } else if (o != Py_None) {
2866 if (context->size + 1 > context->maxsize &&
2867 !_bump(context, 1))
2868 return 0;
2869 Py_INCREF(o);
2870 PyTuple_SET_ITEM(context->tuple,
2871 context->size++, o);
2872 }
2873 }
2874 } else if (PyTuple_Check(item)) {
2875 /* same, for tuples */
2876 size = PyTuple_GET_SIZE(item);
2877 if (context->size + size > context->maxsize &&
2878 !_bump(context, size))
2879 return 0;
2880 for (i = 0; i < size; i++) {
2881 PyObject *o = PyTuple_GET_ITEM(item, i);
2882 if (PyList_Check(o) || PyTuple_Check(o)) {
2883 if (!_flatten1(context, o, depth + 1))
2884 return 0;
2885 } else if (o != Py_None) {
2886 if (context->size + 1 > context->maxsize &&
2887 !_bump(context, 1))
2888 return 0;
2889 Py_INCREF(o);
2890 PyTuple_SET_ITEM(context->tuple,
2891 context->size++, o);
2892 }
2893 }
2894 } else {
2895 PyErr_SetString(PyExc_TypeError, "argument must be sequence");
2896 return 0;
2897 }
2898 return 1;
2899 }
2900
2901 static PyObject *
2902 Tkinter_Flatten(PyObject* self, PyObject* args)
2903 {
2904 FlattenContext context;
2905 PyObject* item;
2906
2907 if (!PyArg_ParseTuple(args, "O:_flatten", &item))
2908 return NULL;
2909
2910 context.maxsize = PySequence_Size(item);
2911 if (context.maxsize <= 0)
2912 return PyTuple_New(0);
2913
2914 context.tuple = PyTuple_New(context.maxsize);
2915 if (!context.tuple)
2916 return NULL;
2917
2918 context.size = 0;
2919
2920 if (!_flatten1(&context, item,0))
2921 return NULL;
2922
2923 if (_PyTuple_Resize(&context.tuple, context.size))
2924 return NULL;
2925
2926 return context.tuple;
2927 }
2928
2929 static PyObject *
2930 Tkinter_Create(PyObject *self, PyObject *args)
2931 {
2932 char *screenName = NULL;
2933 char *baseName = NULL;
2934 char *className = NULL;
2935 int interactive = 0;
2936 int wantobjects = 0;
2937 int wantTk = 1; /* If false, then Tk_Init() doesn't get called */
2938 int sync = 0; /* pass -sync to wish */
2939 char *use = NULL; /* pass -use to wish */
2940
2941 baseName = strrchr(Py_GetProgramName(), '/');
2942 if (baseName != NULL)
2943 baseName++;
2944 else
2945 baseName = Py_GetProgramName();
2946 className = "Tk";
2947
2948 if (!PyArg_ParseTuple(args, "|zssiiiiz:create",
2949 &screenName, &baseName, &className,
2950 &interactive, &wantobjects, &wantTk,
2951 &sync, &use))
2952 return NULL;
2953
2954 return (PyObject *) Tkapp_New(screenName, baseName, className,
2955 interactive, wantobjects, wantTk,
2956 sync, use);
2957 }
2958
2959 static PyObject *
2960 Tkinter_setbusywaitinterval(PyObject *self, PyObject *args)
2961 {
2962 int new_val;
2963 if (!PyArg_ParseTuple(args, "i:setbusywaitinterval", &new_val))
2964 return NULL;
2965 if (new_val < 0) {
2966 PyErr_SetString(PyExc_ValueError,
2967 "busywaitinterval must be >= 0");
2968 return NULL;
2969 }
2970 Tkinter_busywaitinterval = new_val;
2971 Py_INCREF(Py_None);
2972 return Py_None;
2973 }
2974
2975 static char setbusywaitinterval_doc[] =
2976 "setbusywaitinterval(n) -> None\n\
2977 \n\
2978 Set the busy-wait interval in milliseconds between successive\n\
2979 calls to Tcl_DoOneEvent in a threaded Python interpreter.\n\
2980 It should be set to a divisor of the maximum time between\n\
2981 frames in an animation.";
2982
2983 static PyObject *
2984 Tkinter_getbusywaitinterval(PyObject *self, PyObject *args)
2985 {
2986 return PyInt_FromLong(Tkinter_busywaitinterval);
2987 }
2988
2989 static char getbusywaitinterval_doc[] =
2990 "getbusywaitinterval() -> int\n\
2991 \n\
2992 Return the current busy-wait interval between successive\n\
2993 calls to Tcl_DoOneEvent in a threaded Python interpreter.";
2994
2995 static PyMethodDef moduleMethods[] =
2996 {
2997 {"_flatten", Tkinter_Flatten, METH_VARARGS},
2998 {"create", Tkinter_Create, METH_VARARGS},
2999 #ifdef HAVE_CREATEFILEHANDLER
3000 {"createfilehandler", Tkapp_CreateFileHandler, METH_VARARGS},
3001 {"deletefilehandler", Tkapp_DeleteFileHandler, METH_VARARGS},
3002 #endif
3003 {"createtimerhandler", Tkapp_CreateTimerHandler, METH_VARARGS},
3004 {"mainloop", Tkapp_MainLoop, METH_VARARGS},
3005 {"dooneevent", Tkapp_DoOneEvent, METH_VARARGS},
3006 {"quit", Tkapp_Quit, METH_VARARGS},
3007 {"setbusywaitinterval",Tkinter_setbusywaitinterval, METH_VARARGS,
3008 setbusywaitinterval_doc},
3009 {"getbusywaitinterval",(PyCFunction)Tkinter_getbusywaitinterval,
3010 METH_NOARGS, getbusywaitinterval_doc},
3011 {NULL, NULL}
3012 };
3013
3014 #ifdef WAIT_FOR_STDIN
3015
3016 static int stdin_ready = 0;
3017
3018 #ifndef MS_WINDOWS
3019 static void
3020 MyFileProc(void *clientData, int mask)
3021 {
3022 stdin_ready = 1;
3023 }
3024 #endif
3025
3026 #ifdef WITH_THREAD
3027 static PyThreadState *event_tstate = NULL;
3028 #endif
3029
3030 static int
3031 EventHook(void)
3032 {
3033 #ifndef MS_WINDOWS
3034 int tfile;
3035 #endif
3036 #ifdef WITH_THREAD
3037 PyEval_RestoreThread(event_tstate);
3038 #endif
3039 stdin_ready = 0;
3040 errorInCmd = 0;
3041 #ifndef MS_WINDOWS
3042 tfile = fileno(stdin);
3043 Tcl_CreateFileHandler(tfile, TCL_READABLE, MyFileProc, NULL);
3044 #endif
3045 while (!errorInCmd && !stdin_ready) {
3046 int result;
3047 #ifdef MS_WINDOWS
3048 if (_kbhit()) {
3049 stdin_ready = 1;
3050 break;
3051 }
3052 #endif
3053 #if defined(WITH_THREAD) || defined(MS_WINDOWS)
3054 Py_BEGIN_ALLOW_THREADS
3055 if(tcl_lock)PyThread_acquire_lock(tcl_lock, 1);
3056 tcl_tstate = event_tstate;
3057
3058 result = Tcl_DoOneEvent(TCL_DONT_WAIT);
3059
3060 tcl_tstate = NULL;
3061 if(tcl_lock)PyThread_release_lock(tcl_lock);
3062 if (result == 0)
3063 Sleep(Tkinter_busywaitinterval);
3064 Py_END_ALLOW_THREADS
3065 #else
3066 result = Tcl_DoOneEvent(0);
3067 #endif
3068
3069 if (result < 0)
3070 break;
3071 }
3072 #ifndef MS_WINDOWS
3073 Tcl_DeleteFileHandler(tfile);
3074 #endif
3075 if (errorInCmd) {
3076 errorInCmd = 0;
3077 PyErr_Restore(excInCmd, valInCmd, trbInCmd);
3078 excInCmd = valInCmd = trbInCmd = NULL;
3079 PyErr_Print();
3080 }
3081 #ifdef WITH_THREAD
3082 PyEval_SaveThread();
3083 #endif
3084 return 0;
3085 }
3086
3087 #endif
3088
3089 static void
3090 EnableEventHook(void)
3091 {
3092 #ifdef WAIT_FOR_STDIN
3093 if (PyOS_InputHook == NULL) {
3094 #ifdef WITH_THREAD
3095 event_tstate = PyThreadState_Get();
3096 #endif
3097 PyOS_InputHook = EventHook;
3098 }
3099 #endif
3100 }
3101
3102 static void
3103 DisableEventHook(void)
3104 {
3105 #ifdef WAIT_FOR_STDIN
3106 if (Tk_GetNumMainWindows() == 0 && PyOS_InputHook == EventHook) {
3107 PyOS_InputHook = NULL;
3108 }
3109 #endif
3110 }
3111
3112
3113 /* all errors will be checked in one fell swoop in init_tkinter() */
3114 static void
3115 ins_long(PyObject *d, char *name, long val)
3116 {
3117 PyObject *v = PyInt_FromLong(val);
3118 if (v) {
3119 PyDict_SetItemString(d, name, v);
3120 Py_DECREF(v);
3121 }
3122 }
3123 static void
3124 ins_string(PyObject *d, char *name, char *val)
3125 {
3126 PyObject *v = PyString_FromString(val);
3127 if (v) {
3128 PyDict_SetItemString(d, name, v);
3129 Py_DECREF(v);
3130 }
3131 }
3132
3133
3134 PyMODINIT_FUNC
3135 init_tkinter(void)
3136 {
3137 PyObject *m, *d;
3138
3139 Py_TYPE(&Tkapp_Type) = &PyType_Type;
3140
3141 #ifdef WITH_THREAD
3142 tcl_lock = PyThread_allocate_lock();
3143 #endif
3144
3145 m = Py_InitModule("_tkinter", moduleMethods);
3146 if (m == NULL)
3147 return;
3148
3149 d = PyModule_GetDict(m);
3150 Tkinter_TclError = PyErr_NewException("_tkinter.TclError", NULL, NULL);
3151 PyDict_SetItemString(d, "TclError", Tkinter_TclError);
3152
3153 ins_long(d, "READABLE", TCL_READABLE);
3154 ins_long(d, "WRITABLE", TCL_WRITABLE);
3155 ins_long(d, "EXCEPTION", TCL_EXCEPTION);
3156 ins_long(d, "WINDOW_EVENTS", TCL_WINDOW_EVENTS);
3157 ins_long(d, "FILE_EVENTS", TCL_FILE_EVENTS);
3158 ins_long(d, "TIMER_EVENTS", TCL_TIMER_EVENTS);
3159 ins_long(d, "IDLE_EVENTS", TCL_IDLE_EVENTS);
3160 ins_long(d, "ALL_EVENTS", TCL_ALL_EVENTS);
3161 ins_long(d, "DONT_WAIT", TCL_DONT_WAIT);
3162 ins_string(d, "TK_VERSION", TK_VERSION);
3163 ins_string(d, "TCL_VERSION", TCL_VERSION);
3164
3165 PyDict_SetItemString(d, "TkappType", (PyObject *)&Tkapp_Type);
3166
3167 Py_TYPE(&Tktt_Type) = &PyType_Type;
3168 PyDict_SetItemString(d, "TkttType", (PyObject *)&Tktt_Type);
3169
3170 Py_TYPE(&PyTclObject_Type) = &PyType_Type;
3171 PyDict_SetItemString(d, "Tcl_Obj", (PyObject *)&PyTclObject_Type);
3172
3173 #ifdef TK_AQUA
3174 /* Tk_MacOSXSetupTkNotifier must be called before Tcl's subsystems
3175 * start waking up. Note that Tcl_FindExecutable will do this, this
3176 * code must be above it! The original warning from
3177 * tkMacOSXAppInit.c is copied below.
3178 *
3179 * NB - You have to swap in the Tk Notifier BEFORE you start up the
3180 * Tcl interpreter for now. It probably should work to do this
3181 * in the other order, but for now it doesn't seem to.
3182 *
3183 */
3184 Tk_MacOSXSetupTkNotifier();
3185 #endif
3186
3187
3188 /* This helps the dynamic loader; in Unicode aware Tcl versions
3189 it also helps Tcl find its encodings. */
3190 Tcl_FindExecutable(Py_GetProgramName());
3191
3192 if (PyErr_Occurred())
3193 return;
3194
3195 #if 0
3196 /* This was not a good idea; through <Destroy> bindings,
3197 Tcl_Finalize() may invoke Python code but at that point the
3198 interpreter and thread state have already been destroyed! */
3199 Py_AtExit(Tcl_Finalize);
3200 #endif
3201
3202 }
python git mirror