1996-06-26 18:26:04 +00:00
|
|
|
|
/***********************************************************
|
|
|
|
|
Copyright (C) 1994 Steen Lumholt.
|
|
|
|
|
Copyright 1994-1995 by Stichting Mathematisch Centrum, Amsterdam,
|
|
|
|
|
The Netherlands.
|
|
|
|
|
|
|
|
|
|
All Rights Reserved
|
|
|
|
|
|
1996-10-25 14:44:06 +00:00
|
|
|
|
Permission to use, copy, modify, and distribute this software and its
|
|
|
|
|
documentation for any purpose and without fee is hereby granted,
|
1996-06-26 18:26:04 +00:00
|
|
|
|
provided that the above copyright notice appear in all copies and that
|
1996-10-25 14:44:06 +00:00
|
|
|
|
both that copyright notice and this permission notice appear in
|
1996-06-26 18:26:04 +00:00
|
|
|
|
supporting documentation, and that the names of Stichting Mathematisch
|
1996-10-25 14:44:06 +00:00
|
|
|
|
Centrum or CWI or Corporation for National Research Initiatives or
|
|
|
|
|
CNRI not be used in advertising or publicity pertaining to
|
|
|
|
|
distribution of the software without specific, written prior
|
|
|
|
|
permission.
|
1996-06-26 18:26:04 +00:00
|
|
|
|
|
1996-10-25 14:44:06 +00:00
|
|
|
|
While CWI is the initial source for this software, a modified version
|
|
|
|
|
is made available by the Corporation for National Research Initiatives
|
|
|
|
|
(CNRI) at the Internet address ftp://ftp.python.org.
|
|
|
|
|
|
|
|
|
|
STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
|
|
|
|
|
REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
|
|
|
|
|
MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
|
|
|
|
|
CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
|
|
|
|
|
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
|
|
|
|
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
|
|
|
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
|
|
|
PERFORMANCE OF THIS SOFTWARE.
|
1996-06-26 18:26:04 +00:00
|
|
|
|
|
|
|
|
|
******************************************************************/
|
|
|
|
|
|
|
|
|
|
/* _tkinter.c -- Interface to libtk.a and libtcl.a. */
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1996-08-13 21:10:16 +00:00
|
|
|
|
/* TCL/TK VERSION INFO:
|
|
|
|
|
|
|
|
|
|
Unix:
|
1997-07-19 19:57:42 +00:00
|
|
|
|
Tcl/Tk 8.0 (even alpha or beta) or 7.6/4.2 are recommended.
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Versions 7.5/4.1 are the earliest versions still supported.
|
|
|
|
|
Versions 7.4/4.0 or Tk 3.x are no longer supported.
|
1996-08-13 21:10:16 +00:00
|
|
|
|
|
|
|
|
|
Mac and Windows:
|
1997-07-19 19:57:42 +00:00
|
|
|
|
Use Tcl 8.0 if available (even alpha or beta).
|
|
|
|
|
The oldest usable version is 4.1p1/7.5p1.
|
|
|
|
|
|
1998-04-29 16:22:14 +00:00
|
|
|
|
XXX Further speed-up ideas, involving Tcl 8.0 features:
|
|
|
|
|
|
|
|
|
|
- In Tcl_Call(), create Tcl objects from the arguments, possibly using
|
|
|
|
|
intelligent mappings between Python objects and Tcl objects (e.g. ints,
|
|
|
|
|
floats and Tcl window pointers could be handled specially).
|
|
|
|
|
|
|
|
|
|
- Register a new Tcl type, "Python callable", which can be called more
|
|
|
|
|
efficiently and passed to Tcl_EvalObj() directly (if this is possible).
|
|
|
|
|
|
1996-08-13 21:10:16 +00:00
|
|
|
|
*/
|
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
|
1995-09-22 23:49:28 +00:00
|
|
|
|
#include "Python.h"
|
1996-08-08 19:09:53 +00:00
|
|
|
|
#include <ctype.h>
|
1995-09-22 23:49:28 +00:00
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
#ifdef WITH_THREAD
|
1998-10-01 20:42:43 +00:00
|
|
|
|
#include "pythread.h"
|
1998-05-28 23:06:38 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
1998-05-29 01:28:40 +00:00
|
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
|
#include <windows.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
1996-08-20 20:49:56 +00:00
|
|
|
|
#ifdef macintosh
|
|
|
|
|
#define MAC_TCL
|
1997-06-02 22:16:43 +00:00
|
|
|
|
#include "myselect.h"
|
1996-08-20 20:49:56 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
1998-10-01 20:42:43 +00:00
|
|
|
|
#ifdef PYOS_OS2
|
|
|
|
|
#include "myselect.h"
|
|
|
|
|
#endif
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
#include <tcl.h>
|
|
|
|
|
#include <tk.h>
|
|
|
|
|
|
1997-08-01 19:29:02 +00:00
|
|
|
|
#define TKMAJORMINOR (TK_MAJOR_VERSION*1000 + TK_MINOR_VERSION)
|
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
#if TKMAJORMINOR < 4001
|
|
|
|
|
#error "Tk 4.0 or 3.x are not supported -- use 4.1 or higher"
|
|
|
|
|
#endif
|
|
|
|
|
|
1997-08-14 19:57:07 +00:00
|
|
|
|
#if TKMAJORMINOR >= 8000 && defined(macintosh)
|
|
|
|
|
/* Sigh, we have to include this to get at the tcl qd pointer */
|
|
|
|
|
#include <tkMac.h>
|
1998-04-28 16:12:43 +00:00
|
|
|
|
/* And this one we need to clear the menu bar */
|
|
|
|
|
#include <Menus.h>
|
1997-08-14 19:57:07 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
1997-10-08 15:25:37 +00:00
|
|
|
|
#if TKMAJORMINOR < 8000 || !defined(MS_WINDOWS)
|
1997-08-14 19:57:07 +00:00
|
|
|
|
#define HAVE_CREATEFILEHANDLER
|
|
|
|
|
#endif
|
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
#ifdef HAVE_CREATEFILEHANDLER
|
|
|
|
|
|
|
|
|
|
/* Tcl_CreateFileHandler() changed several times; these macros deal with the
|
|
|
|
|
messiness. In Tcl 8.0 and later, it is not available on Windows (and on
|
|
|
|
|
Unix, only because Jack added it back); when available on Windows, it only
|
|
|
|
|
applies to sockets. */
|
|
|
|
|
|
1998-05-22 18:28:17 +00:00
|
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
|
#define FHANDLETYPE TCL_WIN_SOCKET
|
|
|
|
|
#else
|
|
|
|
|
#define FHANDLETYPE TCL_UNIX_FD
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if TKMAJORMINOR < 8000
|
|
|
|
|
#define FHANDLE Tcl_File
|
|
|
|
|
#define MAKEFHANDLE(fd) Tcl_GetFile((ClientData)(fd), FHANDLETYPE)
|
|
|
|
|
#else
|
|
|
|
|
#define FHANDLE int
|
|
|
|
|
#define MAKEFHANDLE(fd) (fd)
|
|
|
|
|
#endif
|
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
/* If Tcl can wait for a Unix file descriptor, define the EventHook() routine
|
|
|
|
|
which uses this to handle Tcl events while the user is typing commands. */
|
|
|
|
|
|
|
|
|
|
#if FHANDLETYPE == TCL_UNIX_FD
|
1998-05-22 18:28:17 +00:00
|
|
|
|
#define WAIT_FOR_STDIN
|
|
|
|
|
#endif
|
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
#endif /* HAVE_CREATEFILEHANDLER */
|
|
|
|
|
|
1998-06-13 13:56:28 +00:00
|
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
|
#include <conio.h>
|
|
|
|
|
#define WAIT_FOR_STDIN
|
|
|
|
|
#endif
|
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
#ifdef WITH_THREAD
|
|
|
|
|
|
|
|
|
|
/* The threading situation is complicated. Tcl is not thread-safe, except for
|
|
|
|
|
Tcl 8.1, which will probably remain in alpha status for another 6 months
|
|
|
|
|
(and the README says that Tk will probably remain thread-unsafe forever).
|
|
|
|
|
So we need to use a lock around all uses of Tcl. Previously, the Python
|
|
|
|
|
interpreter lock was used for this. However, this causes problems when
|
|
|
|
|
other Python threads need to run while Tcl is blocked waiting for events.
|
|
|
|
|
|
|
|
|
|
To solve this problem, a separate lock for Tcl is introduced. Holding it
|
|
|
|
|
is incompatible with holding Python's interpreter lock. The following four
|
|
|
|
|
macros manipulate both locks together.
|
|
|
|
|
|
|
|
|
|
ENTER_TCL and LEAVE_TCL are brackets, just like Py_BEGIN_ALLOW_THREADS and
|
|
|
|
|
Py_END_ALLOW_THREADS. They should be used whenever a call into Tcl is made
|
|
|
|
|
that could call an event handler, or otherwise affect the state of a Tcl
|
|
|
|
|
interpreter. These assume that the surrounding code has the Python
|
|
|
|
|
interpreter lock; inside the brackets, the Python interpreter lock has been
|
|
|
|
|
released and the lock for Tcl has been acquired.
|
|
|
|
|
|
1998-06-15 14:03:52 +00:00
|
|
|
|
Sometimes, it is necessary to have both the Python lock and the Tcl lock.
|
|
|
|
|
(For example, when transferring data from the Tcl interpreter result to a
|
|
|
|
|
Python string object.) This can be done by using different macros to close
|
|
|
|
|
the ENTER_TCL block: ENTER_OVERLAP reacquires the Python lock (and restores
|
|
|
|
|
the thread state) but doesn't release the Tcl lock; LEAVE_OVERLAP_TCL
|
|
|
|
|
releases the Tcl lock.
|
|
|
|
|
|
1998-10-09 20:51:18 +00:00
|
|
|
|
By contrast, ENTER_PYTHON and LEAVE_PYTHON are used in Tcl event
|
1998-05-28 23:06:38 +00:00
|
|
|
|
handlers when the handler needs to use Python. Such event handlers are
|
|
|
|
|
entered while the lock for Tcl is held; the event handler presumably needs
|
1998-10-09 20:51:18 +00:00
|
|
|
|
to use Python. ENTER_PYTHON releases the lock for Tcl and acquires
|
1998-05-28 23:06:38 +00:00
|
|
|
|
the Python interpreter lock, restoring the appropriate thread state, and
|
|
|
|
|
LEAVE_PYTHON releases the Python interpreter lock and re-acquires the lock
|
|
|
|
|
for Tcl. It is okay for ENTER_TCL/LEAVE_TCL pairs to be contained inside
|
1998-10-09 20:51:18 +00:00
|
|
|
|
the code between ENTER_PYTHON and LEAVE_PYTHON.
|
1998-05-28 23:06:38 +00:00
|
|
|
|
|
|
|
|
|
These locks expand to several statements and brackets; they should not be
|
|
|
|
|
used in branches of if statements and the like.
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
1998-12-21 19:32:43 +00:00
|
|
|
|
static PyThread_type_lock tcl_lock = 0;
|
1998-10-09 20:51:18 +00:00
|
|
|
|
static PyThreadState *tcl_tstate = NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
|
|
|
|
|
#define ENTER_TCL \
|
1998-10-09 20:51:18 +00:00
|
|
|
|
{ PyThreadState *tstate = PyThreadState_Get(); Py_BEGIN_ALLOW_THREADS \
|
1998-12-21 19:32:43 +00:00
|
|
|
|
PyThread_acquire_lock(tcl_lock, 1); tcl_tstate = tstate;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
|
|
|
|
|
#define LEAVE_TCL \
|
1998-12-21 19:32:43 +00:00
|
|
|
|
tcl_tstate = NULL; PyThread_release_lock(tcl_lock); Py_END_ALLOW_THREADS}
|
1998-05-28 23:06:38 +00:00
|
|
|
|
|
1998-06-15 04:36:09 +00:00
|
|
|
|
#define ENTER_OVERLAP \
|
|
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
|
|
|
|
|
|
#define LEAVE_OVERLAP_TCL \
|
1998-12-21 19:32:43 +00:00
|
|
|
|
tcl_tstate = NULL; PyThread_release_lock(tcl_lock); }
|
1998-06-15 04:36:09 +00:00
|
|
|
|
|
1998-10-09 20:51:18 +00:00
|
|
|
|
#define ENTER_PYTHON \
|
|
|
|
|
{ PyThreadState *tstate = tcl_tstate; tcl_tstate = NULL; \
|
1998-12-21 19:32:43 +00:00
|
|
|
|
PyThread_release_lock(tcl_lock); PyEval_RestoreThread((tstate)); }
|
1998-05-28 23:06:38 +00:00
|
|
|
|
|
|
|
|
|
#define LEAVE_PYTHON \
|
1998-10-09 20:51:18 +00:00
|
|
|
|
{ PyThreadState *tstate = PyEval_SaveThread(); \
|
1998-12-21 19:32:43 +00:00
|
|
|
|
PyThread_acquire_lock(tcl_lock, 1); tcl_tstate = tstate; }
|
1998-05-28 23:06:38 +00:00
|
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
|
|
#define ENTER_TCL
|
|
|
|
|
#define LEAVE_TCL
|
1998-06-15 04:36:09 +00:00
|
|
|
|
#define ENTER_OVERLAP
|
|
|
|
|
#define LEAVE_OVERLAP_TCL
|
1998-10-09 20:51:18 +00:00
|
|
|
|
#define ENTER_PYTHON
|
1998-05-28 23:06:38 +00:00
|
|
|
|
#define LEAVE_PYTHON
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
1996-02-25 04:50:29 +00:00
|
|
|
|
#ifdef macintosh
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
** Additional cruft needed by Tcl/Tk on the Mac.
|
1996-08-08 19:09:53 +00:00
|
|
|
|
** This is for Tcl 7.5 and Tk 4.1 (patch release 1).
|
1996-02-25 04:50:29 +00:00
|
|
|
|
*/
|
|
|
|
|
|
1996-08-13 21:10:16 +00:00
|
|
|
|
/* ckfree() expects a char* */
|
1996-08-08 19:09:53 +00:00
|
|
|
|
#define FREECAST (char *)
|
|
|
|
|
|
1996-02-25 04:50:29 +00:00
|
|
|
|
#include <Events.h> /* For EventRecord */
|
|
|
|
|
|
|
|
|
|
typedef int (*TclMacConvertEventPtr) Py_PROTO((EventRecord *eventPtr));
|
1997-08-14 19:57:07 +00:00
|
|
|
|
/* They changed the name... */
|
|
|
|
|
#if TKMAJORMINOR < 8000
|
|
|
|
|
#define Tcl_MacSetEventProc TclMacSetEventProc
|
|
|
|
|
#endif
|
|
|
|
|
void Tcl_MacSetEventProc Py_PROTO((TclMacConvertEventPtr procPtr));
|
1996-02-25 04:50:29 +00:00
|
|
|
|
int TkMacConvertEvent Py_PROTO((EventRecord *eventPtr));
|
|
|
|
|
|
|
|
|
|
staticforward int PyMacConvertEvent Py_PROTO((EventRecord *eventPtr));
|
|
|
|
|
|
1998-04-28 16:12:43 +00:00
|
|
|
|
#if defined(__CFM68K__) && !defined(__USING_STATIC_LIBS__)
|
|
|
|
|
#pragma import on
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#include <SIOUX.h>
|
|
|
|
|
extern int SIOUXIsAppWindow(WindowPtr);
|
|
|
|
|
|
|
|
|
|
#if defined(__CFM68K__) && !defined(__USING_STATIC_LIBS__)
|
|
|
|
|
#pragma import reset
|
|
|
|
|
#endif
|
1996-02-25 04:50:29 +00:00
|
|
|
|
#endif /* macintosh */
|
|
|
|
|
|
1996-08-08 19:09:53 +00:00
|
|
|
|
#ifndef FREECAST
|
1996-08-13 21:10:16 +00:00
|
|
|
|
#define FREECAST (char *)
|
1996-08-08 19:09:53 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
/**** Tkapp Object Declaration ****/
|
|
|
|
|
|
|
|
|
|
staticforward PyTypeObject Tkapp_Type;
|
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
typedef struct {
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject_HEAD
|
|
|
|
|
Tcl_Interp *interp;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
} TkappObject;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
|
|
|
|
#define Tkapp_Check(v) ((v)->ob_type == &Tkapp_Type)
|
|
|
|
|
#define Tkapp_Interp(v) (((TkappObject *) (v))->interp)
|
|
|
|
|
#define Tkapp_Result(v) (((TkappObject *) (v))->interp->result)
|
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
#define DEBUG_REFCNT(v) (printf("DEBUG: id=%p, refcnt=%i\n", \
|
1997-01-16 00:15:11 +00:00
|
|
|
|
(void *) v, ((PyObject *) v)->ob_refcnt))
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
/**** Error Handling ****/
|
|
|
|
|
|
|
|
|
|
static PyObject *Tkinter_TclError;
|
1994-07-07 09:25:12 +00:00
|
|
|
|
static int quitMainLoop = 0;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
static int errorInCmd = 0;
|
|
|
|
|
static PyObject *excInCmd;
|
|
|
|
|
static PyObject *valInCmd;
|
1995-01-02 19:30:30 +00:00
|
|
|
|
static PyObject *trbInCmd;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
static PyObject *
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Tkinter_Error(v)
|
|
|
|
|
PyObject *v;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyErr_SetString(Tkinter_TclError, Tkapp_Result(v));
|
|
|
|
|
return NULL;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
|
|
|
|
|
/**** Utils ****/
|
|
|
|
|
|
|
|
|
|
#ifdef WITH_THREAD
|
1998-05-29 01:28:40 +00:00
|
|
|
|
#ifndef MS_WINDOWS
|
1998-08-13 13:29:22 +00:00
|
|
|
|
#include "mytime.h"
|
1999-01-25 21:39:03 +00:00
|
|
|
|
#include "myselect.h"
|
1998-08-13 13:29:22 +00:00
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
/* Millisecond sleep() for Unix platforms. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
Sleep(milli)
|
|
|
|
|
int milli;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1998-05-28 23:06:38 +00:00
|
|
|
|
/* XXX Too bad if you don't have select(). */
|
|
|
|
|
struct timeval t;
|
|
|
|
|
double frac;
|
|
|
|
|
t.tv_sec = milli/1000;
|
|
|
|
|
t.tv_usec = (milli%1000) * 1000;
|
|
|
|
|
select(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &t);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
1998-05-29 01:28:40 +00:00
|
|
|
|
#endif /* MS_WINDOWS */
|
1998-05-28 23:06:38 +00:00
|
|
|
|
#endif /* WITH_THREAD */
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
static char *
|
1997-01-16 00:15:11 +00:00
|
|
|
|
AsString(value, tmp)
|
|
|
|
|
PyObject *value;
|
|
|
|
|
PyObject *tmp;
|
|
|
|
|
{
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (PyString_Check(value))
|
|
|
|
|
return PyString_AsString(value);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
else {
|
|
|
|
|
PyObject *v = PyObject_Str(value);
|
|
|
|
|
PyList_Append(tmp, v);
|
|
|
|
|
Py_DECREF(v);
|
|
|
|
|
return PyString_AsString(v);
|
|
|
|
|
}
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
#define ARGSZ 64
|
|
|
|
|
|
|
|
|
|
static char *
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Merge(args)
|
|
|
|
|
PyObject *args;
|
|
|
|
|
{
|
|
|
|
|
PyObject *tmp = NULL;
|
|
|
|
|
char *argvStore[ARGSZ];
|
|
|
|
|
char **argv = NULL;
|
|
|
|
|
int fvStore[ARGSZ];
|
|
|
|
|
int *fv = NULL;
|
|
|
|
|
int argc = 0, i;
|
|
|
|
|
char *res = NULL;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (!(tmp = PyList_New(0)))
|
|
|
|
|
return NULL;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
argv = argvStore;
|
|
|
|
|
fv = fvStore;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (args == NULL)
|
|
|
|
|
argc = 0;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
else if (!PyTuple_Check(args)) {
|
|
|
|
|
argc = 1;
|
|
|
|
|
fv[0] = 0;
|
|
|
|
|
argv[0] = AsString(args, tmp);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
argc = PyTuple_Size(args);
|
|
|
|
|
|
|
|
|
|
if (argc > ARGSZ) {
|
1997-08-02 00:09:09 +00:00
|
|
|
|
argv = (char **)ckalloc(argc * sizeof(char *));
|
|
|
|
|
fv = (int *)ckalloc(argc * sizeof(int));
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (argv == NULL || fv == NULL) {
|
|
|
|
|
PyErr_NoMemory();
|
|
|
|
|
goto finally;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < argc; i++) {
|
|
|
|
|
PyObject *v = PyTuple_GetItem(args, i);
|
|
|
|
|
if (PyTuple_Check(v)) {
|
|
|
|
|
fv[i] = 1;
|
|
|
|
|
if (!(argv[i] = Merge(v)))
|
|
|
|
|
goto finally;
|
|
|
|
|
}
|
|
|
|
|
else if (v == Py_None) {
|
|
|
|
|
argc = i;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
fv[i] = 0;
|
|
|
|
|
argv[i] = AsString(v, tmp);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
res = Tcl_Merge(argc, argv);
|
|
|
|
|
|
|
|
|
|
finally:
|
|
|
|
|
for (i = 0; i < argc; i++)
|
|
|
|
|
if (fv[i]) {
|
|
|
|
|
ckfree(argv[i]);
|
|
|
|
|
}
|
|
|
|
|
if (argv != argvStore)
|
|
|
|
|
ckfree(FREECAST argv);
|
|
|
|
|
if (fv != fvStore)
|
|
|
|
|
ckfree(FREECAST fv);
|
|
|
|
|
|
|
|
|
|
Py_DECREF(tmp);
|
|
|
|
|
return res;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
static PyObject *
|
1998-05-28 23:06:38 +00:00
|
|
|
|
Split(list)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
char *list;
|
|
|
|
|
{
|
|
|
|
|
int argc;
|
|
|
|
|
char **argv;
|
|
|
|
|
PyObject *v;
|
|
|
|
|
|
|
|
|
|
if (list == NULL) {
|
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
|
return Py_None;
|
|
|
|
|
}
|
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
if (Tcl_SplitList((Tcl_Interp *)NULL, list, &argc, &argv) != TCL_OK) {
|
1997-01-16 00:15:11 +00:00
|
|
|
|
/* Not a list.
|
|
|
|
|
* Could be a quoted string containing funnies, e.g. {"}.
|
|
|
|
|
* Return the string itself.
|
|
|
|
|
*/
|
|
|
|
|
return PyString_FromString(list);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (argc == 0)
|
|
|
|
|
v = PyString_FromString("");
|
|
|
|
|
else if (argc == 1)
|
|
|
|
|
v = PyString_FromString(argv[0]);
|
1997-08-02 00:09:09 +00:00
|
|
|
|
else if ((v = PyTuple_New(argc)) != NULL) {
|
1997-01-16 00:15:11 +00:00
|
|
|
|
int i;
|
|
|
|
|
PyObject *w;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < argc; i++) {
|
1998-05-28 23:06:38 +00:00
|
|
|
|
if ((w = Split(argv[i])) == NULL) {
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Py_DECREF(v);
|
|
|
|
|
v = NULL;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
PyTuple_SetItem(v, i, w);
|
|
|
|
|
}
|
|
|
|
|
}
|
1998-05-28 23:06:38 +00:00
|
|
|
|
Tcl_Free(FREECAST argv);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return v;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
/**** Tkapp Object ****/
|
|
|
|
|
|
|
|
|
|
#ifndef WITH_APPINIT
|
|
|
|
|
int
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tcl_AppInit(interp)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Tcl_Interp *interp;
|
|
|
|
|
{
|
|
|
|
|
Tk_Window main;
|
1996-02-25 04:46:40 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
main = Tk_MainWindow(interp);
|
|
|
|
|
if (Tcl_Init(interp) == TCL_ERROR) {
|
1998-05-12 15:02:41 +00:00
|
|
|
|
PySys_WriteStderr("Tcl_Init error: %s\n", interp->result);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return TCL_ERROR;
|
|
|
|
|
}
|
|
|
|
|
if (Tk_Init(interp) == TCL_ERROR) {
|
1998-05-12 15:02:41 +00:00
|
|
|
|
PySys_WriteStderr("Tk_Init error: %s\n", interp->result);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return TCL_ERROR;
|
|
|
|
|
}
|
|
|
|
|
return TCL_OK;
|
|
|
|
|
}
|
1994-06-20 07:49:28 +00:00
|
|
|
|
#endif /* !WITH_APPINIT */
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
/* Initialize the Tk application; see the `main' function in
|
1997-01-16 00:15:11 +00:00
|
|
|
|
* `tkMain.c'.
|
|
|
|
|
*/
|
1998-05-22 18:28:17 +00:00
|
|
|
|
|
|
|
|
|
static void EnableEventHook(); /* Forward */
|
|
|
|
|
static void DisableEventHook(); /* Forward */
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
static TkappObject *
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Tkapp_New(screenName, baseName, className, interactive)
|
|
|
|
|
char *screenName;
|
|
|
|
|
char *baseName;
|
|
|
|
|
char *className;
|
|
|
|
|
int interactive;
|
|
|
|
|
{
|
|
|
|
|
TkappObject *v;
|
|
|
|
|
char *argv0;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
v = PyObject_NEW(TkappObject, &Tkapp_Type);
|
|
|
|
|
if (v == NULL)
|
|
|
|
|
return NULL;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
v->interp = Tcl_CreateInterp();
|
1996-02-25 04:46:40 +00:00
|
|
|
|
|
1999-11-05 18:09:56 +00:00
|
|
|
|
#if TKMAJORMINOR == 8001
|
|
|
|
|
TclpInitLibraryPath(baseName);
|
|
|
|
|
#endif /* TKMAJORMINOR */
|
|
|
|
|
|
1998-04-28 16:12:43 +00:00
|
|
|
|
#if defined(macintosh) && TKMAJORMINOR >= 8000
|
|
|
|
|
/* This seems to be needed since Tk 8.0 */
|
|
|
|
|
ClearMenuBar();
|
|
|
|
|
TkMacInitMenus(v->interp);
|
|
|
|
|
#endif
|
1998-02-19 21:28:49 +00:00
|
|
|
|
/* Delete the 'exit' command, which can screw things up */
|
|
|
|
|
Tcl_DeleteCommand(v->interp, "exit");
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (screenName != NULL)
|
|
|
|
|
Tcl_SetVar2(v->interp, "env", "DISPLAY",
|
|
|
|
|
screenName, TCL_GLOBAL_ONLY);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
strcpy(argv0, className);
|
1998-04-10 22:27:42 +00:00
|
|
|
|
if (isupper((int)(argv0[0])))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
argv0[0] = tolower(argv0[0]);
|
|
|
|
|
Tcl_SetVar(v->interp, "argv0", argv0, TCL_GLOBAL_ONLY);
|
|
|
|
|
ckfree(argv0);
|
1996-08-08 19:09:53 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (Tcl_AppInit(v->interp) != TCL_OK)
|
1998-07-07 22:25:47 +00:00
|
|
|
|
return (TkappObject *)Tkinter_Error((PyObject *)v);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1998-05-22 18:28:17 +00:00
|
|
|
|
EnableEventHook();
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return v;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
/** Tcl Eval **/
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Tkapp_Call(self, args)
|
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1998-04-29 16:22:14 +00:00
|
|
|
|
/* This is copied from Merge() */
|
|
|
|
|
PyObject *tmp = NULL;
|
|
|
|
|
char *argvStore[ARGSZ];
|
|
|
|
|
char **argv = NULL;
|
|
|
|
|
int fvStore[ARGSZ];
|
|
|
|
|
int *fv = NULL;
|
|
|
|
|
int argc = 0, i;
|
|
|
|
|
PyObject *res = NULL; /* except this has a different type */
|
|
|
|
|
Tcl_CmdInfo info; /* and this is added */
|
|
|
|
|
Tcl_Interp *interp = Tkapp_Interp(self); /* and this too */
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
1998-04-29 16:22:14 +00:00
|
|
|
|
if (!(tmp = PyList_New(0)))
|
|
|
|
|
return NULL;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1998-04-29 16:22:14 +00:00
|
|
|
|
argv = argvStore;
|
|
|
|
|
fv = fvStore;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1998-04-29 16:22:14 +00:00
|
|
|
|
if (args == NULL)
|
|
|
|
|
argc = 0;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
1998-04-29 16:22:14 +00:00
|
|
|
|
else if (!PyTuple_Check(args)) {
|
|
|
|
|
argc = 1;
|
|
|
|
|
fv[0] = 0;
|
|
|
|
|
argv[0] = AsString(args, tmp);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
argc = PyTuple_Size(args);
|
|
|
|
|
|
|
|
|
|
if (argc > ARGSZ) {
|
|
|
|
|
argv = (char **)ckalloc(argc * sizeof(char *));
|
|
|
|
|
fv = (int *)ckalloc(argc * sizeof(int));
|
|
|
|
|
if (argv == NULL || fv == NULL) {
|
|
|
|
|
PyErr_NoMemory();
|
|
|
|
|
goto finally;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < argc; i++) {
|
|
|
|
|
PyObject *v = PyTuple_GetItem(args, i);
|
|
|
|
|
if (PyTuple_Check(v)) {
|
|
|
|
|
fv[i] = 1;
|
|
|
|
|
if (!(argv[i] = Merge(v)))
|
|
|
|
|
goto finally;
|
|
|
|
|
}
|
|
|
|
|
else if (v == Py_None) {
|
|
|
|
|
argc = i;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
fv[i] = 0;
|
|
|
|
|
argv[i] = AsString(v, tmp);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/* End code copied from Merge() */
|
|
|
|
|
|
|
|
|
|
/* All this to avoid a call to Tcl_Merge() and the corresponding call
|
|
|
|
|
to Tcl_SplitList() inside Tcl_Eval()... It can save a bundle! */
|
|
|
|
|
if (Py_VerboseFlag >= 2) {
|
|
|
|
|
for (i = 0; i < argc; i++)
|
1998-05-12 15:02:41 +00:00
|
|
|
|
PySys_WriteStderr("%s ", argv[i]);
|
1998-04-29 16:22:14 +00:00
|
|
|
|
}
|
1998-06-15 04:36:09 +00:00
|
|
|
|
ENTER_TCL
|
|
|
|
|
info.proc = NULL;
|
1998-04-29 16:22:14 +00:00
|
|
|
|
if (argc < 1 ||
|
|
|
|
|
!Tcl_GetCommandInfo(interp, argv[0], &info) ||
|
|
|
|
|
info.proc == NULL)
|
|
|
|
|
{
|
|
|
|
|
char *cmd;
|
|
|
|
|
cmd = Tcl_Merge(argc, argv);
|
|
|
|
|
i = Tcl_Eval(interp, cmd);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
ckfree(cmd);
|
1998-04-29 16:22:14 +00:00
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
Tcl_ResetResult(interp);
|
|
|
|
|
i = (*info.proc)(info.clientData, interp, argc, argv);
|
|
|
|
|
}
|
1998-06-15 04:36:09 +00:00
|
|
|
|
ENTER_OVERLAP
|
|
|
|
|
if (info.proc == NULL && Py_VerboseFlag >= 2)
|
|
|
|
|
PySys_WriteStderr("... use TclEval ");
|
1998-04-29 16:22:14 +00:00
|
|
|
|
if (i == TCL_ERROR) {
|
|
|
|
|
if (Py_VerboseFlag >= 2)
|
1998-05-12 15:02:41 +00:00
|
|
|
|
PySys_WriteStderr("... error: '%s'\n",
|
1998-04-29 16:22:14 +00:00
|
|
|
|
interp->result);
|
|
|
|
|
Tkinter_Error(self);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
if (Py_VerboseFlag >= 2)
|
1998-05-12 15:02:41 +00:00
|
|
|
|
PySys_WriteStderr("-> '%s'\n", interp->result);
|
1998-04-29 16:22:14 +00:00
|
|
|
|
res = PyString_FromString(interp->result);
|
|
|
|
|
}
|
1998-06-15 04:36:09 +00:00
|
|
|
|
LEAVE_OVERLAP_TCL
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
1998-04-29 16:22:14 +00:00
|
|
|
|
/* Copied from Merge() again */
|
|
|
|
|
finally:
|
|
|
|
|
for (i = 0; i < argc; i++)
|
|
|
|
|
if (fv[i]) {
|
|
|
|
|
ckfree(argv[i]);
|
|
|
|
|
}
|
|
|
|
|
if (argv != argvStore)
|
|
|
|
|
ckfree(FREECAST argv);
|
|
|
|
|
if (fv != fvStore)
|
|
|
|
|
ckfree(FREECAST fv);
|
|
|
|
|
|
|
|
|
|
Py_DECREF(tmp);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return res;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
static PyObject *
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Tkapp_GlobalCall(self, args)
|
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
|
|
|
|
{
|
1998-04-29 16:22:14 +00:00
|
|
|
|
/* Could do the same here as for Tkapp_Call(), but this is not used
|
|
|
|
|
much, so I can't be bothered. Unfortunately Tcl doesn't export a
|
|
|
|
|
way for the user to do what all its Global* variants do (save and
|
|
|
|
|
reset the scope pointer, call the local version, restore the saved
|
|
|
|
|
scope pointer). */
|
|
|
|
|
|
1998-06-15 04:36:09 +00:00
|
|
|
|
char *cmd;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *res = NULL;
|
|
|
|
|
|
1998-06-15 04:36:09 +00:00
|
|
|
|
cmd = Merge(args);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (!cmd)
|
|
|
|
|
PyErr_SetString(Tkinter_TclError, "merge failed");
|
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
else {
|
|
|
|
|
int err;
|
|
|
|
|
ENTER_TCL
|
|
|
|
|
err = Tcl_GlobalEval(Tkapp_Interp(self), cmd);
|
1998-06-15 04:36:09 +00:00
|
|
|
|
ENTER_OVERLAP
|
1998-05-28 23:06:38 +00:00
|
|
|
|
if (err == TCL_ERROR)
|
|
|
|
|
res = Tkinter_Error(self);
|
|
|
|
|
else
|
|
|
|
|
res = PyString_FromString(Tkapp_Result(self));
|
1998-06-15 04:36:09 +00:00
|
|
|
|
LEAVE_OVERLAP_TCL
|
1998-05-28 23:06:38 +00:00
|
|
|
|
}
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
if (cmd)
|
|
|
|
|
ckfree(cmd);
|
|
|
|
|
|
|
|
|
|
return res;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Tkapp_Eval(self, args)
|
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
char *script;
|
1998-06-15 04:36:09 +00:00
|
|
|
|
PyObject *res = NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
int err;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "s", &script))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ENTER_TCL
|
|
|
|
|
err = Tcl_Eval(Tkapp_Interp(self), script);
|
1998-06-15 04:36:09 +00:00
|
|
|
|
ENTER_OVERLAP
|
1998-05-28 23:06:38 +00:00
|
|
|
|
if (err == TCL_ERROR)
|
1998-06-15 04:36:09 +00:00
|
|
|
|
res = Tkinter_Error(self);
|
|
|
|
|
else
|
|
|
|
|
res = PyString_FromString(Tkapp_Result(self));
|
|
|
|
|
LEAVE_OVERLAP_TCL
|
|
|
|
|
return res;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Tkapp_GlobalEval(self, args)
|
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
char *script;
|
1998-06-15 04:36:09 +00:00
|
|
|
|
PyObject *res = NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
int err;
|
1998-06-15 04:36:09 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "s", &script))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ENTER_TCL
|
|
|
|
|
err = Tcl_GlobalEval(Tkapp_Interp(self), script);
|
1998-06-15 04:36:09 +00:00
|
|
|
|
ENTER_OVERLAP
|
1998-05-28 23:06:38 +00:00
|
|
|
|
if (err == TCL_ERROR)
|
1998-06-15 04:36:09 +00:00
|
|
|
|
res = Tkinter_Error(self);
|
|
|
|
|
else
|
|
|
|
|
res = PyString_FromString(Tkapp_Result(self));
|
|
|
|
|
LEAVE_OVERLAP_TCL
|
|
|
|
|
return res;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_EvalFile(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
char *fileName;
|
1998-06-15 04:36:09 +00:00
|
|
|
|
PyObject *res = NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
int err;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "s", &fileName))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ENTER_TCL
|
|
|
|
|
err = Tcl_EvalFile(Tkapp_Interp(self), fileName);
|
1998-06-15 04:36:09 +00:00
|
|
|
|
ENTER_OVERLAP
|
1998-05-28 23:06:38 +00:00
|
|
|
|
if (err == TCL_ERROR)
|
1998-06-15 04:36:09 +00:00
|
|
|
|
res = Tkinter_Error(self);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1998-06-15 04:36:09 +00:00
|
|
|
|
else
|
|
|
|
|
res = PyString_FromString(Tkapp_Result(self));
|
|
|
|
|
LEAVE_OVERLAP_TCL
|
|
|
|
|
return res;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Tkapp_Record(self, args)
|
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
char *script;
|
1998-06-15 04:36:09 +00:00
|
|
|
|
PyObject *res = NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
int err;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "s", &script))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ENTER_TCL
|
|
|
|
|
err = Tcl_RecordAndEval(Tkapp_Interp(self), script, TCL_NO_EVAL);
|
1998-06-15 04:36:09 +00:00
|
|
|
|
ENTER_OVERLAP
|
1998-05-28 23:06:38 +00:00
|
|
|
|
if (err == TCL_ERROR)
|
1998-06-15 04:36:09 +00:00
|
|
|
|
res = Tkinter_Error(self);
|
|
|
|
|
else
|
|
|
|
|
res = PyString_FromString(Tkapp_Result(self));
|
|
|
|
|
LEAVE_OVERLAP_TCL
|
|
|
|
|
return res;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Tkapp_AddErrorInfo(self, args)
|
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
char *msg;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "s", &msg))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ENTER_TCL
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Tcl_AddErrorInfo(Tkapp_Interp(self), msg);
|
1998-05-28 23:06:38 +00:00
|
|
|
|
LEAVE_TCL
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
|
return Py_None;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
/** Tcl Variable **/
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-01-16 00:15:11 +00:00
|
|
|
|
SetVar(self, args, flags)
|
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
|
|
|
|
int flags;
|
|
|
|
|
{
|
1998-05-28 23:06:38 +00:00
|
|
|
|
char *name1, *name2, *ok, *s;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *newValue;
|
1998-06-15 04:36:09 +00:00
|
|
|
|
PyObject *tmp;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
1998-06-15 04:36:09 +00:00
|
|
|
|
tmp = PyList_New(0);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (!tmp)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
if (PyArg_ParseTuple(args, "sO", &name1, &newValue)) {
|
1997-01-16 00:15:11 +00:00
|
|
|
|
/* XXX Merge? */
|
1998-05-28 23:06:38 +00:00
|
|
|
|
s = AsString(newValue, tmp);
|
|
|
|
|
ENTER_TCL
|
|
|
|
|
ok = Tcl_SetVar(Tkapp_Interp(self), name1, s, flags);
|
|
|
|
|
LEAVE_TCL
|
|
|
|
|
}
|
1997-01-16 00:15:11 +00:00
|
|
|
|
else {
|
1997-08-02 00:09:09 +00:00
|
|
|
|
PyErr_Clear();
|
1998-05-28 23:06:38 +00:00
|
|
|
|
if (PyArg_ParseTuple(args, "ssO", &name1, &name2, &newValue)) {
|
|
|
|
|
s = AsString (newValue, tmp);
|
|
|
|
|
ENTER_TCL
|
1997-08-02 00:09:09 +00:00
|
|
|
|
ok = Tcl_SetVar2(Tkapp_Interp(self), name1, name2,
|
1998-05-28 23:06:38 +00:00
|
|
|
|
s, flags);
|
|
|
|
|
LEAVE_TCL
|
|
|
|
|
}
|
1997-08-02 00:09:09 +00:00
|
|
|
|
else {
|
1998-05-28 23:06:38 +00:00
|
|
|
|
Py_DECREF(tmp);
|
1997-08-02 00:09:09 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
1997-01-16 00:15:11 +00:00
|
|
|
|
}
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Py_DECREF(tmp);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
if (!ok)
|
|
|
|
|
return Tkinter_Error(self);
|
|
|
|
|
|
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
|
return Py_None;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_SetVar(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return SetVar(self, args, TCL_LEAVE_ERR_MSG);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_GlobalSetVar(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return SetVar(self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
GetVar(self, args, flags)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
|
|
|
|
int flags;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-08-02 00:09:09 +00:00
|
|
|
|
char *name1, *name2=NULL, *s;
|
1998-06-15 04:36:09 +00:00
|
|
|
|
PyObject *res = NULL;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "s|s", &name1, &name2))
|
|
|
|
|
return NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ENTER_TCL
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (name2 == NULL)
|
1998-06-15 04:36:09 +00:00
|
|
|
|
s = Tcl_GetVar(Tkapp_Interp(self), name1, flags);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
else
|
1997-08-02 00:09:09 +00:00
|
|
|
|
s = Tcl_GetVar2(Tkapp_Interp(self), name1, name2, flags);
|
1998-06-15 04:36:09 +00:00
|
|
|
|
ENTER_OVERLAP
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (s == NULL)
|
1998-06-15 04:36:09 +00:00
|
|
|
|
res = Tkinter_Error(self);
|
|
|
|
|
else
|
|
|
|
|
res = PyString_FromString(s);
|
|
|
|
|
LEAVE_OVERLAP_TCL
|
|
|
|
|
return res;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_GetVar(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return GetVar(self, args, TCL_LEAVE_ERR_MSG);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_GlobalGetVar(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return GetVar(self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
UnsetVar(self, args, flags)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
|
|
|
|
int flags;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-08-02 00:09:09 +00:00
|
|
|
|
char *name1, *name2=NULL;
|
1998-06-15 04:36:09 +00:00
|
|
|
|
PyObject *res = NULL;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
int code;
|
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "s|s", &name1, &name2))
|
|
|
|
|
return NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ENTER_TCL
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (name2 == NULL)
|
|
|
|
|
code = Tcl_UnsetVar(Tkapp_Interp(self), name1, flags);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
else
|
1997-08-02 00:09:09 +00:00
|
|
|
|
code = Tcl_UnsetVar2(Tkapp_Interp(self), name1, name2, flags);
|
1998-06-15 04:36:09 +00:00
|
|
|
|
ENTER_OVERLAP
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (code == TCL_ERROR)
|
1998-06-15 04:36:09 +00:00
|
|
|
|
res = Tkinter_Error(self);
|
|
|
|
|
else {
|
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
|
res = Py_None;
|
|
|
|
|
}
|
|
|
|
|
LEAVE_OVERLAP_TCL
|
|
|
|
|
return res;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_UnsetVar(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return UnsetVar(self, args, TCL_LEAVE_ERR_MSG);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_GlobalUnsetVar(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return UnsetVar(self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
/** Tcl to Python **/
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_GetInt(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
char *s;
|
|
|
|
|
int v;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "s", &s))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (Tcl_GetInt(Tkapp_Interp(self), s, &v) == TCL_ERROR)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return Tkinter_Error(self);
|
|
|
|
|
return Py_BuildValue("i", v);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_GetDouble(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
char *s;
|
|
|
|
|
double v;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "s", &s))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (Tcl_GetDouble(Tkapp_Interp(self), s, &v) == TCL_ERROR)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return Tkinter_Error(self);
|
|
|
|
|
return Py_BuildValue("d", v);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_GetBoolean(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
char *s;
|
|
|
|
|
int v;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "s", &s))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (Tcl_GetBoolean(Tkapp_Interp(self), s, &v) == TCL_ERROR)
|
|
|
|
|
return Tkinter_Error(self);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return Py_BuildValue("i", v);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_ExprString(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
char *s;
|
1998-06-15 04:36:09 +00:00
|
|
|
|
PyObject *res = NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
int retval;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "s", &s))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ENTER_TCL
|
|
|
|
|
retval = Tcl_ExprString(Tkapp_Interp(self), s);
|
1998-06-15 04:36:09 +00:00
|
|
|
|
ENTER_OVERLAP
|
1998-05-28 23:06:38 +00:00
|
|
|
|
if (retval == TCL_ERROR)
|
1998-06-15 04:36:09 +00:00
|
|
|
|
res = Tkinter_Error(self);
|
|
|
|
|
else
|
|
|
|
|
res = Py_BuildValue("s", Tkapp_Result(self));
|
|
|
|
|
LEAVE_OVERLAP_TCL
|
|
|
|
|
return res;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_ExprLong(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
char *s;
|
1998-06-15 04:36:09 +00:00
|
|
|
|
PyObject *res = NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
int retval;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
long v;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "s", &s))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ENTER_TCL
|
|
|
|
|
retval = Tcl_ExprLong(Tkapp_Interp(self), s, &v);
|
1998-06-15 04:36:09 +00:00
|
|
|
|
ENTER_OVERLAP
|
1998-05-28 23:06:38 +00:00
|
|
|
|
if (retval == TCL_ERROR)
|
1998-06-15 04:36:09 +00:00
|
|
|
|
res = Tkinter_Error(self);
|
|
|
|
|
else
|
|
|
|
|
res = Py_BuildValue("l", v);
|
|
|
|
|
LEAVE_OVERLAP_TCL
|
|
|
|
|
return res;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_ExprDouble(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
char *s;
|
1998-06-15 04:36:09 +00:00
|
|
|
|
PyObject *res = NULL;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
double v;
|
1997-02-14 22:59:58 +00:00
|
|
|
|
int retval;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "s", &s))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
1997-02-14 22:59:58 +00:00
|
|
|
|
PyFPE_START_PROTECT("Tkapp_ExprDouble", return 0)
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ENTER_TCL
|
1997-08-02 00:09:09 +00:00
|
|
|
|
retval = Tcl_ExprDouble(Tkapp_Interp(self), s, &v);
|
1998-06-15 04:36:09 +00:00
|
|
|
|
ENTER_OVERLAP
|
1997-03-14 04:32:50 +00:00
|
|
|
|
PyFPE_END_PROTECT(retval)
|
1997-02-14 22:59:58 +00:00
|
|
|
|
if (retval == TCL_ERROR)
|
1998-06-15 04:36:09 +00:00
|
|
|
|
res = Tkinter_Error(self);
|
|
|
|
|
else
|
|
|
|
|
res = Py_BuildValue("d", v);
|
|
|
|
|
LEAVE_OVERLAP_TCL
|
|
|
|
|
return res;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_ExprBoolean(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
char *s;
|
1998-06-15 04:36:09 +00:00
|
|
|
|
PyObject *res = NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
int retval;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
int v;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "s", &s))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ENTER_TCL
|
|
|
|
|
retval = Tcl_ExprBoolean(Tkapp_Interp(self), s, &v);
|
1998-06-15 04:36:09 +00:00
|
|
|
|
ENTER_OVERLAP
|
1998-05-28 23:06:38 +00:00
|
|
|
|
if (retval == TCL_ERROR)
|
1998-06-15 04:36:09 +00:00
|
|
|
|
res = Tkinter_Error(self);
|
|
|
|
|
else
|
|
|
|
|
res = Py_BuildValue("i", v);
|
|
|
|
|
LEAVE_OVERLAP_TCL
|
|
|
|
|
return res;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_SplitList(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
char *list;
|
|
|
|
|
int argc;
|
|
|
|
|
char **argv;
|
|
|
|
|
PyObject *v;
|
|
|
|
|
int i;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "s", &list))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (Tcl_SplitList(Tkapp_Interp(self), list, &argc, &argv) == TCL_ERROR)
|
|
|
|
|
return Tkinter_Error(self);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (!(v = PyTuple_New(argc)))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < argc; i++) {
|
|
|
|
|
PyObject *s = PyString_FromString(argv[i]);
|
|
|
|
|
if (!s || PyTuple_SetItem(v, i, s)) {
|
|
|
|
|
Py_DECREF(v);
|
|
|
|
|
v = NULL;
|
|
|
|
|
goto finally;
|
|
|
|
|
}
|
|
|
|
|
}
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
finally:
|
|
|
|
|
ckfree(FREECAST argv);
|
|
|
|
|
return v;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_Split(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
char *list;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "s", &list))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
return Split(list);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_Merge(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
char *s = Merge(args);
|
|
|
|
|
PyObject *res = NULL;
|
|
|
|
|
|
|
|
|
|
if (s) {
|
|
|
|
|
res = PyString_FromString(s);
|
|
|
|
|
ckfree(s);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
PyErr_SetString(Tkinter_TclError, "merge failed");
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return res;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
/** Tcl Command **/
|
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
/* Client data struct */
|
|
|
|
|
typedef struct {
|
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *func;
|
|
|
|
|
} PythonCmd_ClientData;
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
PythonCmd_Error(interp)
|
|
|
|
|
Tcl_Interp *interp;
|
|
|
|
|
{
|
|
|
|
|
errorInCmd = 1;
|
|
|
|
|
PyErr_Fetch(&excInCmd, &valInCmd, &trbInCmd);
|
|
|
|
|
LEAVE_PYTHON
|
|
|
|
|
return TCL_ERROR;
|
|
|
|
|
}
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
/* This is the Tcl command that acts as a wrapper for Python
|
1997-01-16 00:15:11 +00:00
|
|
|
|
* function or method.
|
|
|
|
|
*/
|
1994-06-20 07:49:28 +00:00
|
|
|
|
static int
|
1997-08-02 00:09:09 +00:00
|
|
|
|
PythonCmd(clientData, interp, argc, argv)
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ClientData clientData;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Tcl_Interp *interp;
|
|
|
|
|
int argc;
|
|
|
|
|
char *argv[];
|
|
|
|
|
{
|
1998-05-28 23:06:38 +00:00
|
|
|
|
PythonCmd_ClientData *data = (PythonCmd_ClientData *)clientData;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self, *func, *arg, *res, *tmp;
|
|
|
|
|
int i;
|
|
|
|
|
|
1998-10-09 20:51:18 +00:00
|
|
|
|
ENTER_PYTHON
|
1998-05-28 23:06:38 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
/* TBD: no error checking here since we know, via the
|
|
|
|
|
* Tkapp_CreateCommand() that the client data is a two-tuple
|
|
|
|
|
*/
|
1998-05-28 23:06:38 +00:00
|
|
|
|
self = data->self;
|
|
|
|
|
func = data->func;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
/* Create argument list (argv1, ..., argvN) */
|
|
|
|
|
if (!(arg = PyTuple_New(argc - 1)))
|
|
|
|
|
return PythonCmd_Error(interp);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < (argc - 1); i++) {
|
|
|
|
|
PyObject *s = PyString_FromString(argv[i + 1]);
|
|
|
|
|
if (!s || PyTuple_SetItem(arg, i, s)) {
|
|
|
|
|
Py_DECREF(arg);
|
1998-06-19 04:28:10 +00:00
|
|
|
|
return PythonCmd_Error(interp);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
res = PyEval_CallObject(func, arg);
|
|
|
|
|
Py_DECREF(arg);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (res == NULL)
|
|
|
|
|
return PythonCmd_Error(interp);
|
1994-07-07 09:25:12 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (!(tmp = PyList_New(0))) {
|
|
|
|
|
Py_DECREF(res);
|
|
|
|
|
return PythonCmd_Error(interp);
|
|
|
|
|
}
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Tcl_SetResult(Tkapp_Interp(self), AsString(res, tmp), TCL_VOLATILE);
|
|
|
|
|
Py_DECREF(res);
|
|
|
|
|
Py_DECREF(tmp);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
LEAVE_PYTHON
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return TCL_OK;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
1997-08-02 00:09:09 +00:00
|
|
|
|
PythonCmdDelete(clientData)
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ClientData clientData;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1998-05-28 23:06:38 +00:00
|
|
|
|
PythonCmd_ClientData *data = (PythonCmd_ClientData *)clientData;
|
|
|
|
|
|
1998-10-09 20:51:18 +00:00
|
|
|
|
ENTER_PYTHON
|
1998-05-28 23:06:38 +00:00
|
|
|
|
Py_XDECREF(data->self);
|
|
|
|
|
Py_XDECREF(data->func);
|
|
|
|
|
PyMem_DEL(data);
|
|
|
|
|
LEAVE_PYTHON
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_CreateCommand(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1998-05-28 23:06:38 +00:00
|
|
|
|
PythonCmd_ClientData *data;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
char *cmdName;
|
|
|
|
|
PyObject *func;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
Tcl_Command err;
|
1997-08-02 00:09:09 +00:00
|
|
|
|
|
|
|
|
|
if (!PyArg_ParseTuple(args, "sO", &cmdName, &func))
|
|
|
|
|
return NULL;
|
|
|
|
|
if (!PyCallable_Check(func)) {
|
|
|
|
|
PyErr_SetString(PyExc_TypeError, "command not callable");
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
data = PyMem_NEW(PythonCmd_ClientData, 1);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (!data)
|
|
|
|
|
return NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
Py_XINCREF(self);
|
|
|
|
|
Py_XINCREF(func);
|
|
|
|
|
data->self = self;
|
|
|
|
|
data->func = func;
|
|
|
|
|
|
|
|
|
|
ENTER_TCL
|
|
|
|
|
err = Tcl_CreateCommand(Tkapp_Interp(self), cmdName, PythonCmd,
|
|
|
|
|
(ClientData)data, PythonCmdDelete);
|
|
|
|
|
LEAVE_TCL
|
|
|
|
|
if (err == NULL) {
|
1997-08-02 00:09:09 +00:00
|
|
|
|
PyErr_SetString(Tkinter_TclError, "can't create Tcl command");
|
1998-05-28 23:06:38 +00:00
|
|
|
|
PyMem_DEL(data);
|
1997-08-02 00:09:09 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
|
return Py_None;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_DeleteCommand(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
|
|
|
|
{
|
|
|
|
|
char *cmdName;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
int err;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "s", &cmdName))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ENTER_TCL
|
|
|
|
|
err = Tcl_DeleteCommand(Tkapp_Interp(self), cmdName);
|
|
|
|
|
LEAVE_TCL
|
|
|
|
|
if (err == -1) {
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyErr_SetString(Tkinter_TclError, "can't delete Tcl command");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
|
return Py_None;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
#ifdef HAVE_CREATEFILEHANDLER
|
1994-06-20 07:49:28 +00:00
|
|
|
|
/** File Handler **/
|
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
typedef struct _fhcdata {
|
|
|
|
|
PyObject *func;
|
|
|
|
|
PyObject *file;
|
|
|
|
|
int id;
|
|
|
|
|
struct _fhcdata *next;
|
|
|
|
|
} FileHandler_ClientData;
|
|
|
|
|
|
|
|
|
|
static FileHandler_ClientData *HeadFHCD;
|
|
|
|
|
|
|
|
|
|
static FileHandler_ClientData *
|
|
|
|
|
NewFHCD(func, file, id)
|
|
|
|
|
PyObject *func;
|
|
|
|
|
PyObject *file;
|
|
|
|
|
int id;
|
|
|
|
|
{
|
|
|
|
|
FileHandler_ClientData *p;
|
|
|
|
|
p = PyMem_NEW(FileHandler_ClientData, 1);
|
|
|
|
|
if (p != NULL) {
|
|
|
|
|
Py_XINCREF(func);
|
|
|
|
|
Py_XINCREF(file);
|
|
|
|
|
p->func = func;
|
|
|
|
|
p->file = file;
|
|
|
|
|
p->id = id;
|
|
|
|
|
p->next = HeadFHCD;
|
|
|
|
|
HeadFHCD = p;
|
|
|
|
|
}
|
|
|
|
|
return p;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
DeleteFHCD(id)
|
|
|
|
|
int id;
|
|
|
|
|
{
|
|
|
|
|
FileHandler_ClientData *p, **pp;
|
|
|
|
|
|
|
|
|
|
pp = &HeadFHCD;
|
|
|
|
|
while ((p = *pp) != NULL) {
|
|
|
|
|
if (p->id == id) {
|
|
|
|
|
*pp = p->next;
|
|
|
|
|
Py_XDECREF(p->func);
|
|
|
|
|
Py_XDECREF(p->file);
|
|
|
|
|
PyMem_DEL(p);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
pp = &p->next;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1995-01-10 20:56:29 +00:00
|
|
|
|
static void
|
1997-08-02 00:09:09 +00:00
|
|
|
|
FileHandler(clientData, mask)
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ClientData clientData;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
int mask;
|
|
|
|
|
{
|
1998-05-28 23:06:38 +00:00
|
|
|
|
FileHandler_ClientData *data = (FileHandler_ClientData *)clientData;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *func, *file, *arg, *res;
|
|
|
|
|
|
1998-10-09 20:51:18 +00:00
|
|
|
|
ENTER_PYTHON
|
1998-05-28 23:06:38 +00:00
|
|
|
|
func = data->func;
|
|
|
|
|
file = data->file;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
arg = Py_BuildValue("(Oi)", file, (long) mask);
|
|
|
|
|
res = PyEval_CallObject(func, arg);
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Py_DECREF(arg);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
if (res == NULL) {
|
|
|
|
|
errorInCmd = 1;
|
|
|
|
|
PyErr_Fetch(&excInCmd, &valInCmd, &trbInCmd);
|
|
|
|
|
}
|
|
|
|
|
Py_XDECREF(res);
|
1998-05-28 23:06:38 +00:00
|
|
|
|
LEAVE_PYTHON
|
1994-08-09 14:15:19 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
1997-08-02 00:09:09 +00:00
|
|
|
|
GetFileNo(file)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
/* Either an int >= 0 or an object with a
|
|
|
|
|
*.fileno() method that returns an int >= 0
|
|
|
|
|
*/
|
|
|
|
|
PyObject *file;
|
1994-08-09 14:15:19 +00:00
|
|
|
|
{
|
1995-01-10 20:56:29 +00:00
|
|
|
|
PyObject *meth, *args, *res;
|
1994-08-09 14:15:19 +00:00
|
|
|
|
int id;
|
|
|
|
|
if (PyInt_Check(file)) {
|
|
|
|
|
id = PyInt_AsLong(file);
|
|
|
|
|
if (id < 0)
|
|
|
|
|
PyErr_SetString(PyExc_ValueError, "invalid file id");
|
|
|
|
|
return id;
|
|
|
|
|
}
|
|
|
|
|
args = PyTuple_New(0);
|
|
|
|
|
if (args == NULL)
|
|
|
|
|
return -1;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
meth = PyObject_GetAttrString(file, "fileno");
|
|
|
|
|
if (meth == NULL) {
|
|
|
|
|
Py_DECREF(args);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
1994-08-09 14:15:19 +00:00
|
|
|
|
res = PyEval_CallObject(meth, args);
|
|
|
|
|
Py_DECREF(args);
|
|
|
|
|
Py_DECREF(meth);
|
|
|
|
|
if (res == NULL)
|
|
|
|
|
return -1;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
1994-08-09 14:15:19 +00:00
|
|
|
|
if (PyInt_Check(res))
|
|
|
|
|
id = PyInt_AsLong(res);
|
|
|
|
|
else
|
|
|
|
|
id = -1;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
1994-08-09 14:15:19 +00:00
|
|
|
|
if (id < 0)
|
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
|
"invalid fileno() return value");
|
|
|
|
|
Py_DECREF(res);
|
|
|
|
|
return id;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_CreateFileHandler(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args; /* Is (file, mask, func) */
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1998-05-28 23:06:38 +00:00
|
|
|
|
FileHandler_ClientData *data;
|
|
|
|
|
PyObject *file, *func;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
int mask, id;
|
1998-05-22 18:28:17 +00:00
|
|
|
|
FHANDLE tfile;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "OiO", &file, &mask, &func))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
id = GetFileNo(file);
|
|
|
|
|
if (id < 0)
|
|
|
|
|
return NULL;
|
|
|
|
|
if (!PyCallable_Check(func)) {
|
1997-08-02 00:09:09 +00:00
|
|
|
|
PyErr_SetString(PyExc_TypeError, "bad argument list");
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
data = NewFHCD(func, file, id);
|
|
|
|
|
if (data == NULL)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
|
1998-05-22 18:28:17 +00:00
|
|
|
|
tfile = MAKEFHANDLE(id);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
/* Ought to check for null Tcl_File object... */
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ENTER_TCL
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Tcl_CreateFileHandler(tfile, mask, FileHandler, (ClientData) data);
|
1998-05-28 23:06:38 +00:00
|
|
|
|
LEAVE_TCL
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Py_INCREF(Py_None);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return Py_None;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_DeleteFileHandler(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args; /* Args: file */
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *file;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
FileHandler_ClientData *data;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
int id;
|
1998-05-22 18:28:17 +00:00
|
|
|
|
FHANDLE tfile;
|
1996-05-16 17:17:31 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "O", &file))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
id = GetFileNo(file);
|
|
|
|
|
if (id < 0)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
DeleteFHCD(id);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1998-05-22 18:28:17 +00:00
|
|
|
|
tfile = MAKEFHANDLE(id);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
/* Ought to check for null Tcl_File object... */
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ENTER_TCL
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Tcl_DeleteFileHandler(tfile);
|
1998-05-28 23:06:38 +00:00
|
|
|
|
LEAVE_TCL
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Py_INCREF(Py_None);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return Py_None;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
1997-08-14 19:57:07 +00:00
|
|
|
|
#endif /* HAVE_CREATEFILEHANDLER */
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
1994-11-10 22:50:21 +00:00
|
|
|
|
/**** Tktt Object (timer token) ****/
|
|
|
|
|
|
|
|
|
|
staticforward PyTypeObject Tktt_Type;
|
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
typedef struct {
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject_HEAD
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tcl_TimerToken token;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *func;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
} TkttObject;
|
1994-11-10 22:50:21 +00:00
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tktt_DeleteTimerHandler(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
|
|
|
|
{
|
|
|
|
|
TkttObject *v = (TkttObject *)self;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
PyObject *func = v->func;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
if (v->token != NULL) {
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tcl_DeleteTimerHandler(v->token);
|
1998-05-28 23:06:38 +00:00
|
|
|
|
v->token = NULL;
|
|
|
|
|
}
|
|
|
|
|
if (func != NULL) {
|
1997-01-16 00:15:11 +00:00
|
|
|
|
v->func = NULL;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
Py_DECREF(func);
|
|
|
|
|
Py_DECREF(v); /* See Tktt_New() */
|
1997-01-16 00:15:11 +00:00
|
|
|
|
}
|
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
|
return Py_None;
|
1994-11-10 22:50:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyMethodDef Tktt_methods[] =
|
|
|
|
|
{
|
1997-08-02 00:09:09 +00:00
|
|
|
|
{"deletetimerhandler", Tktt_DeleteTimerHandler, 1},
|
1997-01-16 00:15:11 +00:00
|
|
|
|
{NULL, NULL}
|
1994-11-10 22:50:21 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static TkttObject *
|
1998-05-28 23:06:38 +00:00
|
|
|
|
Tktt_New(func)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *func;
|
1994-11-10 22:50:21 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
TkttObject *v;
|
1994-11-10 22:50:21 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
v = PyObject_NEW(TkttObject, &Tktt_Type);
|
|
|
|
|
if (v == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
Py_INCREF(func);
|
|
|
|
|
v->token = NULL;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
v->func = func;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
|
|
|
|
|
/* Extra reference, deleted when called or when handler is deleted */
|
|
|
|
|
Py_INCREF(v);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return v;
|
1994-11-10 22:50:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tktt_Dealloc(self)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
1994-11-10 22:50:21 +00:00
|
|
|
|
{
|
1998-05-28 23:06:38 +00:00
|
|
|
|
TkttObject *v = (TkttObject *)self;
|
|
|
|
|
PyObject *func = v->func;
|
|
|
|
|
|
|
|
|
|
Py_XDECREF(func);
|
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
PyMem_DEL(self);
|
1994-11-10 22:50:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
1998-05-12 14:36:19 +00:00
|
|
|
|
static PyObject *
|
|
|
|
|
Tktt_Repr(self)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
1994-11-10 22:50:21 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
TkttObject *v = (TkttObject *)self;
|
1998-05-12 14:36:19 +00:00
|
|
|
|
char buf[100];
|
1994-11-10 22:50:21 +00:00
|
|
|
|
|
1998-05-12 14:36:19 +00:00
|
|
|
|
sprintf(buf, "<tktimertoken at 0x%lx%s>", (long)v,
|
1997-01-16 00:15:11 +00:00
|
|
|
|
v->func == NULL ? ", handler deleted" : "");
|
1998-05-12 14:36:19 +00:00
|
|
|
|
return PyString_FromString(buf);
|
1994-11-10 22:50:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tktt_GetAttr(self, name)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
char *name;
|
1994-11-10 22:50:21 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return Py_FindMethod(Tktt_methods, self, name);
|
1994-11-10 22:50:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyTypeObject Tktt_Type =
|
|
|
|
|
{
|
1997-08-02 00:09:09 +00:00
|
|
|
|
PyObject_HEAD_INIT(NULL)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
0, /*ob_size */
|
|
|
|
|
"tktimertoken", /*tp_name */
|
1997-08-02 00:09:09 +00:00
|
|
|
|
sizeof(TkttObject), /*tp_basicsize */
|
1997-01-16 00:15:11 +00:00
|
|
|
|
0, /*tp_itemsize */
|
|
|
|
|
Tktt_Dealloc, /*tp_dealloc */
|
1998-05-12 14:36:19 +00:00
|
|
|
|
0, /*tp_print */
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Tktt_GetAttr, /*tp_getattr */
|
|
|
|
|
0, /*tp_setattr */
|
|
|
|
|
0, /*tp_compare */
|
1998-05-12 14:36:19 +00:00
|
|
|
|
Tktt_Repr, /*tp_repr */
|
1997-01-16 00:15:11 +00:00
|
|
|
|
0, /*tp_as_number */
|
|
|
|
|
0, /*tp_as_sequence */
|
|
|
|
|
0, /*tp_as_mapping */
|
|
|
|
|
0, /*tp_hash */
|
1994-11-10 22:50:21 +00:00
|
|
|
|
};
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
1994-11-10 22:50:21 +00:00
|
|
|
|
/** Timer Handler **/
|
|
|
|
|
|
|
|
|
|
static void
|
1997-08-02 00:09:09 +00:00
|
|
|
|
TimerHandler(clientData)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
ClientData clientData;
|
|
|
|
|
{
|
1998-05-28 23:06:38 +00:00
|
|
|
|
TkttObject *v = (TkttObject *)clientData;
|
|
|
|
|
PyObject *func = v->func;
|
|
|
|
|
PyObject *res;
|
|
|
|
|
|
|
|
|
|
if (func == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
v->func = NULL;
|
|
|
|
|
|
1998-10-09 20:51:18 +00:00
|
|
|
|
ENTER_PYTHON
|
1998-05-28 23:06:38 +00:00
|
|
|
|
|
|
|
|
|
res = PyEval_CallObject(func, NULL);
|
|
|
|
|
Py_DECREF(func);
|
|
|
|
|
Py_DECREF(v); /* See Tktt_New() */
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
if (res == NULL) {
|
|
|
|
|
errorInCmd = 1;
|
|
|
|
|
PyErr_Fetch(&excInCmd, &valInCmd, &trbInCmd);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
Py_DECREF(res);
|
1998-05-28 23:06:38 +00:00
|
|
|
|
|
|
|
|
|
LEAVE_PYTHON
|
1994-11-10 22:50:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_CreateTimerHandler(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args; /* Is (milliseconds, func) */
|
|
|
|
|
{
|
|
|
|
|
int milliseconds;
|
|
|
|
|
PyObject *func;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
TkttObject *v;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "iO", &milliseconds, &func))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
if (!PyCallable_Check(func)) {
|
1997-08-02 00:09:09 +00:00
|
|
|
|
PyErr_SetString(PyExc_TypeError, "bad argument list");
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
1998-05-28 23:06:38 +00:00
|
|
|
|
v = Tktt_New(func);
|
|
|
|
|
v->token = Tcl_CreateTimerHandler(milliseconds, TimerHandler,
|
|
|
|
|
(ClientData)v);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
return (PyObject *) v;
|
1994-11-10 22:50:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
/** Event Loop **/
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_MainLoop(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
int threshold = 0;
|
1998-10-09 20:51:18 +00:00
|
|
|
|
#ifdef WITH_THREAD
|
|
|
|
|
PyThreadState *tstate = PyThreadState_Get();
|
|
|
|
|
#endif
|
1994-11-10 22:50:21 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "|i", &threshold))
|
|
|
|
|
return NULL;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
quitMainLoop = 0;
|
|
|
|
|
while (Tk_GetNumMainWindows() > threshold &&
|
|
|
|
|
!quitMainLoop &&
|
|
|
|
|
!errorInCmd)
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-08-02 00:09:09 +00:00
|
|
|
|
int result;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
|
|
|
|
|
#ifdef WITH_THREAD
|
1998-06-15 04:36:09 +00:00
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
1998-12-21 19:32:43 +00:00
|
|
|
|
PyThread_acquire_lock(tcl_lock, 1);
|
1998-10-09 20:51:18 +00:00
|
|
|
|
tcl_tstate = tstate;
|
1997-08-02 00:09:09 +00:00
|
|
|
|
result = Tcl_DoOneEvent(TCL_DONT_WAIT);
|
1998-10-09 20:51:18 +00:00
|
|
|
|
tcl_tstate = NULL;
|
1998-12-21 19:32:43 +00:00
|
|
|
|
PyThread_release_lock(tcl_lock);
|
1998-05-28 23:06:38 +00:00
|
|
|
|
if (result == 0)
|
|
|
|
|
Sleep(20);
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Py_END_ALLOW_THREADS
|
1997-08-19 01:00:50 +00:00
|
|
|
|
#else
|
|
|
|
|
result = Tcl_DoOneEvent(0);
|
|
|
|
|
#endif
|
1998-05-28 23:06:38 +00:00
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (PyErr_CheckSignals() != 0)
|
|
|
|
|
return NULL;
|
|
|
|
|
if (result < 0)
|
|
|
|
|
break;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
}
|
|
|
|
|
quitMainLoop = 0;
|
|
|
|
|
|
|
|
|
|
if (errorInCmd) {
|
|
|
|
|
errorInCmd = 0;
|
|
|
|
|
PyErr_Restore(excInCmd, valInCmd, trbInCmd);
|
|
|
|
|
excInCmd = valInCmd = trbInCmd = NULL;
|
|
|
|
|
return NULL;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
|
return Py_None;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1995-01-10 17:42:51 +00:00
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_DoOneEvent(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1995-01-10 17:42:51 +00:00
|
|
|
|
{
|
1997-08-02 00:09:09 +00:00
|
|
|
|
int flags = 0;
|
1997-01-16 00:15:11 +00:00
|
|
|
|
int rv;
|
1995-01-10 17:42:51 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "|i", &flags))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ENTER_TCL
|
1997-08-02 00:09:09 +00:00
|
|
|
|
rv = Tcl_DoOneEvent(flags);
|
1998-05-28 23:06:38 +00:00
|
|
|
|
LEAVE_TCL
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return Py_BuildValue("i", rv);
|
1995-01-10 17:42:51 +00:00
|
|
|
|
}
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_Quit(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
quitMainLoop = 1;
|
|
|
|
|
Py_INCREF(Py_None);
|
|
|
|
|
return Py_None;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1998-04-29 16:17:01 +00:00
|
|
|
|
static PyObject *
|
|
|
|
|
Tkapp_InterpAddr(self, args)
|
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
if (!PyArg_ParseTuple(args, ""))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
return PyInt_FromLong((long)Tkapp_Interp(self));
|
|
|
|
|
}
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
/**** Tkapp Method List ****/
|
|
|
|
|
|
|
|
|
|
static PyMethodDef Tkapp_methods[] =
|
|
|
|
|
{
|
1997-08-02 00:09:09 +00:00
|
|
|
|
{"call", Tkapp_Call, 0},
|
|
|
|
|
{"globalcall", Tkapp_GlobalCall, 0},
|
|
|
|
|
{"eval", Tkapp_Eval, 1},
|
|
|
|
|
{"globaleval", Tkapp_GlobalEval, 1},
|
|
|
|
|
{"evalfile", Tkapp_EvalFile, 1},
|
|
|
|
|
{"record", Tkapp_Record, 1},
|
|
|
|
|
{"adderrorinfo", Tkapp_AddErrorInfo, 1},
|
|
|
|
|
{"setvar", Tkapp_SetVar, 1},
|
|
|
|
|
{"globalsetvar", Tkapp_GlobalSetVar, 1},
|
|
|
|
|
{"getvar", Tkapp_GetVar, 1},
|
|
|
|
|
{"globalgetvar", Tkapp_GlobalGetVar, 1},
|
|
|
|
|
{"unsetvar", Tkapp_UnsetVar, 1},
|
|
|
|
|
{"globalunsetvar", Tkapp_GlobalUnsetVar, 1},
|
|
|
|
|
{"getint", Tkapp_GetInt, 1},
|
|
|
|
|
{"getdouble", Tkapp_GetDouble, 1},
|
|
|
|
|
{"getboolean", Tkapp_GetBoolean, 1},
|
|
|
|
|
{"exprstring", Tkapp_ExprString, 1},
|
|
|
|
|
{"exprlong", Tkapp_ExprLong, 1},
|
|
|
|
|
{"exprdouble", Tkapp_ExprDouble, 1},
|
|
|
|
|
{"exprboolean", Tkapp_ExprBoolean, 1},
|
|
|
|
|
{"splitlist", Tkapp_SplitList, 1},
|
|
|
|
|
{"split", Tkapp_Split, 1},
|
|
|
|
|
{"merge", Tkapp_Merge, 0},
|
|
|
|
|
{"createcommand", Tkapp_CreateCommand, 1},
|
|
|
|
|
{"deletecommand", Tkapp_DeleteCommand, 1},
|
1997-08-14 19:57:07 +00:00
|
|
|
|
#ifdef HAVE_CREATEFILEHANDLER
|
1997-08-02 00:09:09 +00:00
|
|
|
|
{"createfilehandler", Tkapp_CreateFileHandler, 1},
|
|
|
|
|
{"deletefilehandler", Tkapp_DeleteFileHandler, 1},
|
1997-08-07 00:12:22 +00:00
|
|
|
|
#endif
|
1997-08-02 00:09:09 +00:00
|
|
|
|
{"createtimerhandler", Tkapp_CreateTimerHandler, 1},
|
1997-01-16 00:15:11 +00:00
|
|
|
|
{"mainloop", Tkapp_MainLoop, 1},
|
|
|
|
|
{"dooneevent", Tkapp_DoOneEvent, 1},
|
1997-08-02 00:09:09 +00:00
|
|
|
|
{"quit", Tkapp_Quit, 1},
|
1998-04-29 16:17:01 +00:00
|
|
|
|
{"interpaddr", Tkapp_InterpAddr, 1},
|
1997-01-16 00:15:11 +00:00
|
|
|
|
{NULL, NULL}
|
1994-06-20 07:49:28 +00:00
|
|
|
|
};
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
/**** Tkapp Type Methods ****/
|
|
|
|
|
|
|
|
|
|
static void
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_Dealloc(self)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1998-05-28 23:06:38 +00:00
|
|
|
|
ENTER_TCL
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tcl_DeleteInterp(Tkapp_Interp(self));
|
1998-05-28 23:06:38 +00:00
|
|
|
|
LEAVE_TCL
|
1997-08-02 00:09:09 +00:00
|
|
|
|
PyMem_DEL(self);
|
1998-05-22 18:28:17 +00:00
|
|
|
|
DisableEventHook();
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkapp_GetAttr(self, name)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
char *name;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-08-02 00:09:09 +00:00
|
|
|
|
return Py_FindMethod(Tkapp_methods, self, name);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyTypeObject Tkapp_Type =
|
|
|
|
|
{
|
1997-08-02 00:09:09 +00:00
|
|
|
|
PyObject_HEAD_INIT(NULL)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
0, /*ob_size */
|
|
|
|
|
"tkapp", /*tp_name */
|
1997-08-02 00:09:09 +00:00
|
|
|
|
sizeof(TkappObject), /*tp_basicsize */
|
1997-01-16 00:15:11 +00:00
|
|
|
|
0, /*tp_itemsize */
|
|
|
|
|
Tkapp_Dealloc, /*tp_dealloc */
|
|
|
|
|
0, /*tp_print */
|
|
|
|
|
Tkapp_GetAttr, /*tp_getattr */
|
|
|
|
|
0, /*tp_setattr */
|
|
|
|
|
0, /*tp_compare */
|
|
|
|
|
0, /*tp_repr */
|
|
|
|
|
0, /*tp_as_number */
|
|
|
|
|
0, /*tp_as_sequence */
|
|
|
|
|
0, /*tp_as_mapping */
|
|
|
|
|
0, /*tp_hash */
|
1994-06-20 07:49:28 +00:00
|
|
|
|
};
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
/**** Tkinter Module ****/
|
|
|
|
|
|
|
|
|
|
static PyObject *
|
1997-08-02 00:09:09 +00:00
|
|
|
|
Tkinter_Create(self, args)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *self;
|
|
|
|
|
PyObject *args;
|
|
|
|
|
{
|
|
|
|
|
char *screenName = NULL;
|
|
|
|
|
char *baseName = NULL;
|
|
|
|
|
char *className = NULL;
|
|
|
|
|
int interactive = 0;
|
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
baseName = strrchr(Py_GetProgramName(), '/');
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (baseName != NULL)
|
|
|
|
|
baseName++;
|
|
|
|
|
else
|
|
|
|
|
baseName = Py_GetProgramName();
|
|
|
|
|
className = "Tk";
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (!PyArg_ParseTuple(args, "|zssi",
|
|
|
|
|
&screenName, &baseName, &className,
|
|
|
|
|
&interactive))
|
|
|
|
|
return NULL;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return (PyObject *) Tkapp_New(screenName, baseName, className,
|
|
|
|
|
interactive);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static PyMethodDef moduleMethods[] =
|
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
{"create", Tkinter_Create, 1},
|
1997-08-14 19:57:07 +00:00
|
|
|
|
#ifdef HAVE_CREATEFILEHANDLER
|
1997-08-02 00:09:09 +00:00
|
|
|
|
{"createfilehandler", Tkapp_CreateFileHandler, 1},
|
|
|
|
|
{"deletefilehandler", Tkapp_DeleteFileHandler, 1},
|
1997-08-07 00:12:22 +00:00
|
|
|
|
#endif
|
1997-08-02 00:09:09 +00:00
|
|
|
|
{"createtimerhandler", Tkapp_CreateTimerHandler, 1},
|
1997-01-16 00:15:11 +00:00
|
|
|
|
{"mainloop", Tkapp_MainLoop, 1},
|
|
|
|
|
{"dooneevent", Tkapp_DoOneEvent, 1},
|
1997-08-02 00:09:09 +00:00
|
|
|
|
{"quit", Tkapp_Quit, 1},
|
1997-01-16 00:15:11 +00:00
|
|
|
|
{NULL, NULL}
|
1994-06-20 07:49:28 +00:00
|
|
|
|
};
|
|
|
|
|
|
1998-05-22 18:28:17 +00:00
|
|
|
|
#ifdef WAIT_FOR_STDIN
|
|
|
|
|
|
|
|
|
|
static int stdin_ready = 0;
|
|
|
|
|
|
1998-06-13 13:56:28 +00:00
|
|
|
|
#ifndef MS_WINDOWS
|
1998-05-22 18:28:17 +00:00
|
|
|
|
static void
|
|
|
|
|
MyFileProc(clientData, mask)
|
|
|
|
|
void *clientData;
|
|
|
|
|
int mask;
|
|
|
|
|
{
|
|
|
|
|
stdin_ready = 1;
|
|
|
|
|
}
|
1998-06-13 13:56:28 +00:00
|
|
|
|
#endif
|
1998-05-22 18:28:17 +00:00
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
static PyThreadState *event_tstate = NULL;
|
1997-10-07 18:51:41 +00:00
|
|
|
|
|
1994-06-20 07:49:28 +00:00
|
|
|
|
static int
|
1997-08-02 00:09:09 +00:00
|
|
|
|
EventHook()
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1998-06-13 13:56:28 +00:00
|
|
|
|
#ifndef MS_WINDOWS
|
1998-05-28 23:06:38 +00:00
|
|
|
|
FHANDLE tfile;
|
1998-06-13 13:56:28 +00:00
|
|
|
|
#endif
|
1998-11-17 03:45:24 +00:00
|
|
|
|
#ifdef WITH_THREAD
|
1998-06-13 13:56:28 +00:00
|
|
|
|
PyEval_RestoreThread(event_tstate);
|
1998-11-17 03:45:24 +00:00
|
|
|
|
#endif
|
1998-05-22 18:28:17 +00:00
|
|
|
|
stdin_ready = 0;
|
1998-06-13 13:56:28 +00:00
|
|
|
|
errorInCmd = 0;
|
|
|
|
|
#ifndef MS_WINDOWS
|
|
|
|
|
tfile = MAKEFHANDLE(fileno(stdin));
|
1998-05-22 18:28:17 +00:00
|
|
|
|
Tcl_CreateFileHandler(tfile, TCL_READABLE, MyFileProc, NULL);
|
1998-06-13 13:56:28 +00:00
|
|
|
|
#endif
|
1998-05-28 23:06:38 +00:00
|
|
|
|
while (!errorInCmd && !stdin_ready) {
|
|
|
|
|
int result;
|
1998-06-13 13:56:28 +00:00
|
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
|
if (_kbhit()) {
|
|
|
|
|
stdin_ready = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
#if defined(WITH_THREAD) || defined(MS_WINDOWS)
|
1998-06-15 04:36:09 +00:00
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
1998-12-21 19:32:43 +00:00
|
|
|
|
PyThread_acquire_lock(tcl_lock, 1);
|
1998-10-12 16:26:22 +00:00
|
|
|
|
tcl_tstate = event_tstate;
|
1998-10-09 20:51:18 +00:00
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
result = Tcl_DoOneEvent(TCL_DONT_WAIT);
|
1998-10-09 20:51:18 +00:00
|
|
|
|
|
|
|
|
|
tcl_tstate = NULL;
|
1998-12-21 19:32:43 +00:00
|
|
|
|
PyThread_release_lock(tcl_lock);
|
1998-05-28 23:06:38 +00:00
|
|
|
|
if (result == 0)
|
|
|
|
|
Sleep(20);
|
|
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
|
#else
|
|
|
|
|
result = Tcl_DoOneEvent(0);
|
1998-05-22 18:28:17 +00:00
|
|
|
|
#endif
|
1998-05-28 23:06:38 +00:00
|
|
|
|
|
|
|
|
|
if (result < 0)
|
|
|
|
|
break;
|
|
|
|
|
}
|
1998-06-13 13:56:28 +00:00
|
|
|
|
#ifndef MS_WINDOWS
|
1998-05-28 23:06:38 +00:00
|
|
|
|
Tcl_DeleteFileHandler(tfile);
|
1998-06-13 13:56:28 +00:00
|
|
|
|
#endif
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (errorInCmd) {
|
|
|
|
|
errorInCmd = 0;
|
|
|
|
|
PyErr_Restore(excInCmd, valInCmd, trbInCmd);
|
|
|
|
|
excInCmd = valInCmd = trbInCmd = NULL;
|
|
|
|
|
PyErr_Print();
|
|
|
|
|
}
|
1998-11-17 03:45:24 +00:00
|
|
|
|
#ifdef WITH_THREAD
|
1998-06-13 13:56:28 +00:00
|
|
|
|
PyEval_SaveThread();
|
1998-11-17 03:45:24 +00:00
|
|
|
|
#endif
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return 0;
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1998-05-28 23:06:38 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
1998-05-22 18:28:17 +00:00
|
|
|
|
static void
|
|
|
|
|
EnableEventHook()
|
|
|
|
|
{
|
1998-05-28 23:06:38 +00:00
|
|
|
|
#ifdef WAIT_FOR_STDIN
|
1998-05-22 18:28:17 +00:00
|
|
|
|
if (PyOS_InputHook == NULL) {
|
1998-11-17 03:45:24 +00:00
|
|
|
|
#ifdef WITH_THREAD
|
1998-05-28 23:06:38 +00:00
|
|
|
|
event_tstate = PyThreadState_Get();
|
1998-11-17 03:45:24 +00:00
|
|
|
|
#endif
|
1998-05-22 18:28:17 +00:00
|
|
|
|
PyOS_InputHook = EventHook;
|
|
|
|
|
}
|
1998-05-28 23:06:38 +00:00
|
|
|
|
#endif
|
1998-05-22 18:28:17 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
DisableEventHook()
|
|
|
|
|
{
|
1998-05-28 23:06:38 +00:00
|
|
|
|
#ifdef WAIT_FOR_STDIN
|
1998-05-22 18:28:17 +00:00
|
|
|
|
if (Tk_GetNumMainWindows() == 0 && PyOS_InputHook == EventHook) {
|
|
|
|
|
PyOS_InputHook = NULL;
|
|
|
|
|
}
|
1998-05-28 23:06:38 +00:00
|
|
|
|
#endif
|
1998-05-22 18:28:17 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
/* all errors will be checked in one fell swoop in init_tkinter() */
|
|
|
|
|
static void
|
|
|
|
|
ins_long(d, name, val)
|
|
|
|
|
PyObject *d;
|
|
|
|
|
char *name;
|
|
|
|
|
long val;
|
|
|
|
|
{
|
|
|
|
|
PyObject *v = PyInt_FromLong(val);
|
|
|
|
|
if (v) {
|
|
|
|
|
PyDict_SetItemString(d, name, v);
|
|
|
|
|
Py_DECREF(v);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
static void
|
|
|
|
|
ins_string(d, name, val)
|
|
|
|
|
PyObject *d;
|
|
|
|
|
char *name;
|
|
|
|
|
char *val;
|
|
|
|
|
{
|
|
|
|
|
PyObject *v = PyString_FromString(val);
|
|
|
|
|
if (v) {
|
|
|
|
|
PyDict_SetItemString(d, name, v);
|
|
|
|
|
Py_DECREF(v);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
1998-12-04 18:50:17 +00:00
|
|
|
|
DL_EXPORT(void)
|
1997-08-02 00:09:09 +00:00
|
|
|
|
init_tkinter()
|
1994-06-20 07:49:28 +00:00
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
PyObject *m, *d;
|
|
|
|
|
|
|
|
|
|
Tkapp_Type.ob_type = &PyType_Type;
|
1998-05-28 23:06:38 +00:00
|
|
|
|
|
|
|
|
|
#ifdef WITH_THREAD
|
1998-12-21 19:32:43 +00:00
|
|
|
|
tcl_lock = PyThread_allocate_lock();
|
1998-05-28 23:06:38 +00:00
|
|
|
|
#endif
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
|
|
|
|
m = Py_InitModule("_tkinter", moduleMethods);
|
|
|
|
|
|
|
|
|
|
d = PyModule_GetDict(m);
|
|
|
|
|
Tkinter_TclError = Py_BuildValue("s", "TclError");
|
|
|
|
|
PyDict_SetItemString(d, "TclError", Tkinter_TclError);
|
|
|
|
|
|
1997-08-02 00:09:09 +00:00
|
|
|
|
ins_long(d, "READABLE", TCL_READABLE);
|
|
|
|
|
ins_long(d, "WRITABLE", TCL_WRITABLE);
|
|
|
|
|
ins_long(d, "EXCEPTION", TCL_EXCEPTION);
|
|
|
|
|
ins_long(d, "WINDOW_EVENTS", TCL_WINDOW_EVENTS);
|
|
|
|
|
ins_long(d, "FILE_EVENTS", TCL_FILE_EVENTS);
|
|
|
|
|
ins_long(d, "TIMER_EVENTS", TCL_TIMER_EVENTS);
|
|
|
|
|
ins_long(d, "IDLE_EVENTS", TCL_IDLE_EVENTS);
|
|
|
|
|
ins_long(d, "ALL_EVENTS", TCL_ALL_EVENTS);
|
|
|
|
|
ins_long(d, "DONT_WAIT", TCL_DONT_WAIT);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
ins_string(d, "TK_VERSION", TK_VERSION);
|
|
|
|
|
ins_string(d, "TCL_VERSION", TCL_VERSION);
|
1994-06-20 07:49:28 +00:00
|
|
|
|
|
1997-09-13 00:44:23 +00:00
|
|
|
|
PyDict_SetItemString(d, "TkappType", (PyObject *)&Tkapp_Type);
|
1998-05-28 23:06:38 +00:00
|
|
|
|
|
|
|
|
|
Tktt_Type.ob_type = &PyType_Type;
|
1997-09-13 00:44:23 +00:00
|
|
|
|
PyDict_SetItemString(d, "TkttType", (PyObject *)&Tktt_Type);
|
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
if (PyErr_Occurred())
|
1998-02-06 22:35:46 +00:00
|
|
|
|
return;
|
|
|
|
|
|
1998-07-14 18:02:13 +00:00
|
|
|
|
#if 0
|
|
|
|
|
/* This was not a good idea; through <Destroy> bindings,
|
|
|
|
|
Tcl_Finalize() may invoke Python code but at that point the
|
|
|
|
|
interpreter and thread state have already been destroyed! */
|
1998-04-20 18:47:52 +00:00
|
|
|
|
#if TKMAJORMINOR >= 8000
|
1998-02-06 22:35:46 +00:00
|
|
|
|
Py_AtExit(Tcl_Finalize);
|
1998-04-20 18:47:52 +00:00
|
|
|
|
#endif
|
1998-07-14 18:02:13 +00:00
|
|
|
|
#endif
|
1998-02-06 22:35:46 +00:00
|
|
|
|
|
1995-10-31 16:15:12 +00:00
|
|
|
|
#ifdef macintosh
|
1997-08-14 19:57:07 +00:00
|
|
|
|
/*
|
|
|
|
|
** Part of this code is stolen from MacintoshInit in tkMacAppInit.
|
|
|
|
|
** Most of the initializations in that routine (toolbox init calls and
|
|
|
|
|
** such) have already been done for us, so we only need these.
|
|
|
|
|
*/
|
|
|
|
|
#if TKMAJORMINOR >= 8000
|
|
|
|
|
tcl_macQdPtr = &qd;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
Tcl_MacSetEventProc(PyMacConvertEvent);
|
1996-02-25 04:50:29 +00:00
|
|
|
|
#if GENERATINGCFM
|
1997-01-16 00:15:11 +00:00
|
|
|
|
mac_addlibresources();
|
1996-02-25 04:50:29 +00:00
|
|
|
|
#endif /* GENERATINGCFM */
|
|
|
|
|
#endif /* macintosh */
|
1994-06-20 07:49:28 +00:00
|
|
|
|
}
|
1995-09-22 23:49:28 +00:00
|
|
|
|
|
1996-02-25 04:50:29 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
|
1995-09-22 23:49:28 +00:00
|
|
|
|
#ifdef macintosh
|
1996-02-25 04:46:40 +00:00
|
|
|
|
|
|
|
|
|
/*
|
1996-02-25 04:50:29 +00:00
|
|
|
|
** Anyone who embeds Tcl/Tk on the Mac must define panic().
|
1996-02-25 04:46:40 +00:00
|
|
|
|
*/
|
|
|
|
|
|
1995-09-22 23:49:28 +00:00
|
|
|
|
void
|
|
|
|
|
panic(char * format, ...)
|
|
|
|
|
{
|
1997-01-16 00:15:11 +00:00
|
|
|
|
va_list varg;
|
1995-09-22 23:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
va_start(varg, format);
|
1995-09-22 23:49:28 +00:00
|
|
|
|
|
1998-08-05 13:53:32 +00:00
|
|
|
|
vfprintf(stderr, format, varg);
|
1997-01-16 00:15:11 +00:00
|
|
|
|
(void) fflush(stderr);
|
1995-09-22 23:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
va_end(varg);
|
1995-09-22 23:49:28 +00:00
|
|
|
|
|
1997-01-16 00:15:11 +00:00
|
|
|
|
Py_FatalError("Tcl/Tk panic");
|
1995-09-22 23:49:28 +00:00
|
|
|
|
}
|
1996-02-25 04:46:40 +00:00
|
|
|
|
|
1996-02-25 04:50:29 +00:00
|
|
|
|
/*
|
|
|
|
|
** Pass events to SIOUX before passing them to Tk.
|
|
|
|
|
*/
|
1996-02-25 04:46:40 +00:00
|
|
|
|
|
1996-02-25 04:50:29 +00:00
|
|
|
|
static int
|
|
|
|
|
PyMacConvertEvent(eventPtr)
|
1997-01-16 00:15:11 +00:00
|
|
|
|
EventRecord *eventPtr;
|
1995-11-14 10:34:45 +00:00
|
|
|
|
{
|
1998-04-28 16:12:43 +00:00
|
|
|
|
WindowPtr frontwin;
|
|
|
|
|
/*
|
1998-05-28 23:06:38 +00:00
|
|
|
|
** Sioux eats too many events, so we don't pass it everything. We
|
|
|
|
|
** always pass update events to Sioux, and we only pass other events if
|
1998-04-28 16:12:43 +00:00
|
|
|
|
** the Sioux window is frontmost. This means that Tk menus don't work
|
|
|
|
|
** in that case, but at least we can scroll the sioux window.
|
|
|
|
|
** Note that the SIOUXIsAppWindow() routine we use here is not really
|
|
|
|
|
** part of the external interface of Sioux...
|
|
|
|
|
*/
|
|
|
|
|
frontwin = FrontWindow();
|
|
|
|
|
if ( eventPtr->what == updateEvt || SIOUXIsAppWindow(frontwin) ) {
|
|
|
|
|
if (SIOUXHandleOneEvent(eventPtr))
|
|
|
|
|
return 0; /* Nothing happened to the Tcl event queue */
|
|
|
|
|
}
|
1997-01-16 00:15:11 +00:00
|
|
|
|
return TkMacConvertEvent(eventPtr);
|
1995-11-14 10:34:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
1997-08-14 19:57:07 +00:00
|
|
|
|
#if defined(USE_GUSI) && TKMAJORMINOR < 8000
|
1997-06-02 22:16:43 +00:00
|
|
|
|
/*
|
|
|
|
|
* For Python we have to override this routine (from TclMacNotify),
|
|
|
|
|
* since we use GUSI for our sockets, not Tcl streams. Hence, we have
|
|
|
|
|
* to use GUSI select to see whether our socket is ready. Note that
|
|
|
|
|
* createfilehandler (above) sets the type to TCL_UNIX_FD for our
|
|
|
|
|
* files and sockets.
|
|
|
|
|
*
|
|
|
|
|
* NOTE: this code was lifted from Tcl 7.6, it may need to be modified
|
|
|
|
|
* for other versions. */
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
Tcl_FileReady(file, mask)
|
|
|
|
|
Tcl_File file; /* File handle for a stream. */
|
|
|
|
|
int mask; /* OR'ed combination of TCL_READABLE,
|
|
|
|
|
* TCL_WRITABLE, and TCL_EXCEPTION:
|
|
|
|
|
* indicates conditions caller cares about. */
|
|
|
|
|
{
|
|
|
|
|
int type;
|
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
|
|
fd = (int) Tcl_GetFileInfo(file, &type);
|
|
|
|
|
|
|
|
|
|
if (type == TCL_MAC_SOCKET) {
|
|
|
|
|
return TclMacSocketReady(file, mask);
|
|
|
|
|
} else if (type == TCL_MAC_FILE) {
|
|
|
|
|
/*
|
|
|
|
|
* Under the Macintosh, files are always ready, so we just
|
|
|
|
|
* return the mask that was passed in.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
return mask;
|
|
|
|
|
} else if (type == TCL_UNIX_FD) {
|
|
|
|
|
fd_set readset, writeset, excset;
|
|
|
|
|
struct timeval tv;
|
|
|
|
|
|
|
|
|
|
FD_ZERO(&readset);
|
|
|
|
|
FD_ZERO(&writeset);
|
|
|
|
|
FD_ZERO(&excset);
|
|
|
|
|
|
|
|
|
|
if ( mask & TCL_READABLE ) FD_SET(fd, &readset);
|
|
|
|
|
if ( mask & TCL_WRITABLE ) FD_SET(fd, &writeset);
|
|
|
|
|
if ( mask & TCL_EXCEPTION ) FD_SET(fd, &excset);
|
|
|
|
|
|
|
|
|
|
tv.tv_sec = tv.tv_usec = 0;
|
|
|
|
|
if ( select(fd+1, &readset, &writeset, &excset, &tv) <= 0 )
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
mask = 0;
|
|
|
|
|
if ( FD_ISSET(fd, &readset) ) mask |= TCL_READABLE;
|
|
|
|
|
if ( FD_ISSET(fd, &writeset) ) mask |= TCL_WRITABLE;
|
|
|
|
|
if ( FD_ISSET(fd, &excset) ) mask |= TCL_EXCEPTION;
|
|
|
|
|
|
|
|
|
|
return mask;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif /* USE_GUSI */
|
|
|
|
|
|
1996-02-25 04:50:29 +00:00
|
|
|
|
#if GENERATINGCFM
|
1996-02-25 04:46:40 +00:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
** Additional Mac specific code for dealing with shared libraries.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <Resources.h>
|
|
|
|
|
#include <CodeFragments.h>
|
|
|
|
|
|
|
|
|
|
static int loaded_from_shlib = 0;
|
|
|
|
|
static FSSpec library_fss;
|
1995-09-22 23:49:28 +00:00
|
|
|
|
|
1995-10-31 16:15:12 +00:00
|
|
|
|
/*
|
|
|
|
|
** If this module is dynamically loaded the following routine should
|
|
|
|
|
** be the init routine. It takes care of adding the shared library to
|
|
|
|
|
** the resource-file chain, so that the tk routines can find their
|
|
|
|
|
** resources.
|
|
|
|
|
*/
|
|
|
|
|
OSErr pascal
|
1997-04-29 15:49:04 +00:00
|
|
|
|
init_tkinter_shlib(CFragInitBlockPtr data)
|
1995-10-31 16:15:12 +00:00
|
|
|
|
{
|
1996-08-26 14:37:15 +00:00
|
|
|
|
__initialize();
|
1995-10-31 16:15:12 +00:00
|
|
|
|
if ( data == nil ) return noErr;
|
1997-04-29 15:49:04 +00:00
|
|
|
|
if ( data->fragLocator.where == kDataForkCFragLocator ) {
|
1995-10-31 16:15:12 +00:00
|
|
|
|
library_fss = *data->fragLocator.u.onDisk.fileSpec;
|
|
|
|
|
loaded_from_shlib = 1;
|
1997-04-29 15:49:04 +00:00
|
|
|
|
} else if ( data->fragLocator.where == kResourceCFragLocator ) {
|
1995-10-31 16:15:12 +00:00
|
|
|
|
library_fss = *data->fragLocator.u.inSegs.fileSpec;
|
|
|
|
|
loaded_from_shlib = 1;
|
|
|
|
|
}
|
|
|
|
|
return noErr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
** Insert the library resources into the search path. Put them after
|
|
|
|
|
** the resources from the application. Again, we ignore errors.
|
|
|
|
|
*/
|
1996-02-25 04:46:40 +00:00
|
|
|
|
static
|
1995-10-31 16:15:12 +00:00
|
|
|
|
mac_addlibresources()
|
|
|
|
|
{
|
|
|
|
|
if ( !loaded_from_shlib )
|
|
|
|
|
return;
|
|
|
|
|
(void)FSpOpenResFile(&library_fss, fsRdPerm);
|
|
|
|
|
}
|
|
|
|
|
|
1996-02-25 04:50:29 +00:00
|
|
|
|
#endif /* GENERATINGCFM */
|
|
|
|
|
#endif /* macintosh */
|