home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Tools / Languages / Python 1.1 / Modules / tkintermodule.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-14  |  21.5 KB  |  1,077 lines  |  [TEXT/KAHL]
  1. /* tkintermodule.c -- Interface to libtk.a and libtcl.a.
  2.    Copyright (C) 1994 Steen Lumholt */
  3.  
  4. #include <Python.h>
  5.  
  6. #define PyInit_tkinter inittkinter
  7.  
  8. #include <tcl.h>
  9. #include <tk.h>
  10.  
  11. extern char *getprogramname ();
  12.  
  13. /* Internal declarations from tkInt.h.  */ 
  14. extern int tk_NumMainWindows;
  15. extern struct { Tk_Window win; } *tkMainWindowList;
  16.  
  17. /**** Tkapp Object Declaration ****/
  18.  
  19. staticforward PyTypeObject Tkapp_Type;
  20.  
  21. typedef struct
  22.   {
  23.     PyObject_HEAD
  24.     Tcl_Interp *interp;
  25.     Tk_Window tkwin;
  26.   }
  27. TkappObject;
  28.  
  29. #define Tkapp_Check(v) ((v)->ob_type == &Tkapp_Type)
  30. #define Tkapp_Tkwin(v)  (((TkappObject *) (v))->tkwin)
  31. #define Tkapp_Interp(v) (((TkappObject *) (v))->interp)
  32. #define Tkapp_Result(v) (((TkappObject *) (v))->interp->result)
  33.  
  34. #define DEBUG_REFCNT(v) (printf ("DEBUG: id=%p, refcnt=%i\n", \
  35.                  (void *) v, ((PyObject *) v)->ob_refcnt))
  36.  
  37. /**** Error Handling ****/
  38.  
  39. static PyObject *Tkinter_TclError;
  40. static int quitMainLoop = 0;
  41. static int errorInCmd = 0;
  42. static PyObject *excInCmd;
  43. static PyObject *valInCmd;
  44.  
  45. static PyObject *
  46. Tkinter_Error (v)
  47.      PyObject *v;
  48. {
  49.   PyErr_SetString (Tkinter_TclError, Tkapp_Result (v));
  50.   return NULL;
  51. }
  52.  
  53. int
  54. PythonCmd_Error (interp)
  55.      Tcl_Interp *interp;
  56. {
  57.   errorInCmd = 1;
  58.   PyErr_GetAndClear (&excInCmd, &valInCmd);
  59.   return TCL_ERROR;
  60. }
  61.  
  62. /**** Utils ****/
  63.  
  64. static char *
  65. AsString (value, tmp)
  66.      PyObject *value;
  67.      PyObject *tmp;
  68. {
  69.   if (PyString_Check (value))
  70.     return PyString_AsString (value);
  71.   else
  72.     {
  73.       PyObject *v;
  74.  
  75.       v = strobject (value);
  76.       PyList_Append (tmp, v);
  77.       Py_DECREF (v);
  78.       return PyString_AsString (v);
  79.     }
  80. }
  81.  
  82. #define ARGSZ 64
  83.  
  84. static char *
  85. Merge (args)
  86.      PyObject *args;
  87. {
  88.   PyObject *tmp;
  89.   char *argvStore[ARGSZ];
  90.   char **argv;
  91.   int fvStore[ARGSZ];
  92.   int *fv;
  93.   int argc;
  94.   char *res;
  95.   int i;
  96.  
  97.   tmp = PyList_New (0);
  98.   argv = argvStore;
  99.   fv = fvStore;
  100.  
  101.   if (!PyTuple_Check (args))
  102.     {
  103.       argc = 1;
  104.       fv[0] = 0;
  105.       argv[0] = AsString (args, tmp);
  106.     }
  107.   else
  108.     {
  109.       PyObject *v;
  110.  
  111.       if (PyTuple_Size (args) > ARGSZ)
  112.     {
  113.       argv = malloc (PyTuple_Size (args) * sizeof (char *));
  114.       fv = malloc (PyTuple_Size (args) * sizeof (int));
  115.       if (argv == NULL || fv == NULL)
  116.         PyErr_NoMemory ();
  117.     }
  118.  
  119.       argc = PyTuple_Size (args);
  120.       for (i = 0; i < argc; i++)
  121.     {
  122.       v = PyTuple_GetItem (args, i);
  123.       if (PyTuple_Check (v))
  124.         {
  125.           fv[i] = 1;
  126.           argv[i] = Merge (v);
  127.         }
  128.       else if (v == Py_None)
  129.         {
  130.           argc = i;
  131.           break;
  132.         }
  133.       else
  134.         {
  135.           fv[i] = 0;
  136.           argv[i] = AsString (v, tmp);
  137.         }
  138.     }
  139.     }
  140.  
  141.   res = Tcl_Merge (argc, argv);
  142.  
  143.   Py_DECREF (tmp);
  144.   for (i = 0; i < argc; i++)
  145.     if (fv[i]) free (argv[i]);
  146.   if (argv != argvStore)
  147.     free (argv);
  148.   if (fv != fvStore)
  149.     free (fv);
  150.  
  151.   return res;
  152. }
  153.  
  154. static PyObject *
  155. Split (self, list)
  156.      PyObject *self;
  157.      char *list;
  158. {
  159.   int argc;
  160.   char **argv;
  161.   PyObject *v;
  162.  
  163.   if (list == NULL)
  164.     {
  165.       Py_INCREF (Py_None);
  166.       return Py_None;
  167.     }
  168.  
  169.   if (Tcl_SplitList (Tkapp_Interp (self), list, &argc, &argv) == TCL_ERROR)
  170.     return Tkinter_Error (self);
  171.  
  172.   if (argc == 0)
  173.     v = PyString_FromString ("");
  174.   else if (argc == 1)
  175.     v = PyString_FromString (argv[0]);
  176.   else
  177.     {
  178.       int i;
  179.  
  180.       v = PyTuple_New (argc);
  181.       for (i = 0; i < argc; i++)
  182.     PyTuple_SetItem (v, i, Split (self, argv[i]));
  183.     }
  184.  
  185.   free (argv);
  186.   return v;
  187. }
  188.  
  189. /**** Tkapp Object ****/
  190.  
  191. #ifndef WITH_APPINIT
  192. int
  193. Tcl_AppInit (interp)
  194.      Tcl_Interp *interp;
  195. {
  196.   if (Tcl_Init (interp) == TCL_ERROR)
  197.     return TCL_ERROR;
  198.   if (Tk_Init (interp) == TCL_ERROR)
  199.     return TCL_ERROR;
  200.   return TCL_OK;
  201. }
  202. #endif /* !WITH_APPINIT */
  203.  
  204. /* Initialize the Tk application; see the `main' function in
  205.    `tkMain.c'.  */
  206. static TkappObject *
  207. Tkapp_New (screenName, baseName, className, interactive)
  208.      char *screenName;
  209.      char *baseName;
  210.      char *className;
  211.      int interactive;
  212. {
  213.   TkappObject *v;
  214.   
  215.   v = PyObject_NEW (TkappObject, &Tkapp_Type);
  216.   if (v == NULL)
  217.     return NULL;
  218.  
  219.   v->interp = Tcl_CreateInterp ();
  220.   v->tkwin = Tk_CreateMainWindow (v->interp, screenName, 
  221.                   baseName, className);
  222.   if (v->tkwin == NULL)
  223.     return (TkappObject *) Tkinter_Error ((PyObject *) v);
  224.  
  225.   Tk_GeometryRequest (v->tkwin, 200, 200);
  226.  
  227.   if (screenName != NULL)
  228.     Tcl_SetVar2 (v->interp, "env", "DISPLAY", screenName, TCL_GLOBAL_ONLY);
  229.  
  230.   if (interactive)
  231.     Tcl_SetVar (v->interp, "tcl_interactive", "1", TCL_GLOBAL_ONLY);
  232.   else
  233.     Tcl_SetVar (v->interp, "tcl_interactive", "0", TCL_GLOBAL_ONLY);
  234.  
  235.   if (Tcl_AppInit (v->interp) != TCL_OK)
  236.     {
  237.       PyErr_SetString (Tkinter_TclError, "Tcl_AppInit failed"); /* XXX */
  238.       return NULL;
  239.     }
  240.  
  241.   return v;
  242. }
  243.  
  244. /** Tcl Eval **/
  245.  
  246. static PyObject *
  247. Tkapp_Call (self, args)
  248.      PyObject *self;
  249.      PyObject *args;
  250. {
  251.   char *cmd;
  252.  
  253.   cmd = Merge (args);
  254.   if (Tcl_Eval (Tkapp_Interp (self), cmd) == TCL_ERROR)
  255.     {
  256.       free (cmd);
  257.       return Tkinter_Error (self);
  258.     }
  259.  
  260.   free (cmd);
  261.   return PyString_FromString (Tkapp_Result (self));
  262. }
  263.  
  264. static PyObject *
  265. Tkapp_GlobalCall (self, args)
  266.      PyObject *self;
  267.      PyObject *args;
  268. {
  269.   char *cmd;
  270.  
  271.   cmd = Merge (args);
  272.   if (Tcl_GlobalEval (Tkapp_Interp (self), cmd) == TCL_ERROR)
  273.     {
  274.       free (cmd);
  275.       return Tkinter_Error (self);
  276.     }
  277.   
  278.   free (cmd);
  279.   return PyString_FromString (Tkapp_Result (self));
  280. }
  281.  
  282. static PyObject *
  283. Tkapp_Eval (self, args)
  284.      PyObject *self;
  285.      PyObject *args;
  286. {
  287.   char *script;
  288.   
  289.   if (!PyArg_Parse (args, "s", &script))
  290.     return NULL;
  291.  
  292.   if (Tcl_Eval (Tkapp_Interp (self), script) == TCL_ERROR)
  293.     return Tkinter_Error (self);
  294.   
  295.   return PyString_FromString (Tkapp_Result (self));
  296. }
  297.  
  298. static PyObject *
  299. Tkapp_GlobalEval (self, args)
  300.      PyObject *self;
  301.      PyObject *args;
  302. {
  303.   char *script;
  304.   
  305.   if (!PyArg_Parse (args, "s", &script))
  306.     return NULL;
  307.  
  308.   if (Tcl_GlobalEval (Tkapp_Interp (self), script) == TCL_ERROR)
  309.     return Tkinter_Error (self);
  310.  
  311.   return PyString_FromString (Tkapp_Result (self));
  312. }
  313.  
  314. static PyObject *
  315. Tkapp_EvalFile (self, args)
  316.      PyObject *self;
  317.      PyObject *args;
  318. {
  319.   char *fileName;
  320.  
  321.   if (!PyArg_Parse (args, "s", &fileName))
  322.     return NULL;
  323.  
  324.   if (Tcl_EvalFile (Tkapp_Interp (self), fileName) == TCL_ERROR)
  325.     return Tkinter_Error (self);
  326.  
  327.   return PyString_FromString (Tkapp_Result (self));
  328. }
  329.  
  330. static PyObject *
  331. Tkapp_Record (self, args)
  332.      PyObject *self;
  333.      PyObject *args;
  334. {
  335.   char *script;
  336.  
  337.   if (!PyArg_Parse (args, "s", &script))
  338.     return NULL;
  339.  
  340.   if (Tcl_RecordAndEval (Tkapp_Interp (self), 
  341.              script, TCL_NO_EVAL) == TCL_ERROR)
  342.     return Tkinter_Error (self);
  343.  
  344.   return PyString_FromString (Tkapp_Result (self));
  345. }
  346.  
  347. static PyObject *
  348. Tkapp_AddErrorInfo (self, args)
  349.      PyObject *self;
  350.      PyObject *args;
  351. {
  352.   char *msg;
  353.  
  354.   if (!PyArg_Parse (args, "s", &msg))
  355.     return NULL;
  356.   Tcl_AddErrorInfo (Tkapp_Interp (self), msg);
  357.  
  358.   Py_INCREF(Py_None);
  359.   return Py_None;
  360. }
  361.  
  362. /** Tcl Variable **/
  363.  
  364. static PyObject *
  365. SetVar (self, args, flags)
  366.      PyObject *self;
  367.      PyObject *args;
  368.      int flags;
  369. {
  370.   char *name1, *name2, *ok;
  371.   PyObject *newValue;
  372.   PyObject *tmp;
  373.  
  374.   tmp = PyList_New (0);
  375.  
  376.   if (PyArg_Parse (args, "(sO)", &name1, &newValue))
  377.     ok = Tcl_SetVar (Tkapp_Interp (self), name1, 
  378.              AsString (newValue, tmp), flags); /* XXX Merge? */
  379.   else if (PyArg_Parse (args, "(ssO)", &name1, &name2, &newValue))
  380.     ok = Tcl_SetVar2 (Tkapp_Interp (self), name1, name2, 
  381.               AsString (newValue, tmp), flags);
  382.   else
  383.     {
  384.       Py_DECREF (tmp);
  385.       return NULL;
  386.     }
  387.   Py_DECREF (tmp);
  388.  
  389.   if (!ok)
  390.     return Tkinter_Error (self);
  391.  
  392.   Py_INCREF (Py_None);
  393.   return Py_None;
  394. }
  395.  
  396. static PyObject *
  397. Tkapp_SetVar (self, args)
  398.      PyObject *self;
  399.      PyObject *args;
  400. {
  401.   return SetVar (self, args, TCL_LEAVE_ERR_MSG);
  402. }
  403.  
  404. static PyObject *
  405. Tkapp_GlobalSetVar (self, args)
  406.      PyObject *self;
  407.      PyObject *args;
  408. {
  409.   return SetVar (self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
  410. }
  411.  
  412. static PyObject *
  413. GetVar (self, args, flags)
  414.      PyObject *self;
  415.      PyObject *args;
  416.      int flags;
  417. {
  418.   char *name1, *name2, *s;
  419.  
  420.   if (PyArg_Parse (args, "s", &name1))
  421.     s = Tcl_GetVar (Tkapp_Interp (self), name1, flags);
  422.   else if (PyArg_Parse (args, "(ss)", &name1, &name2))
  423.     s = Tcl_GetVar2 (Tkapp_Interp (self), name1, name2, flags);
  424.   else
  425.     return NULL;
  426.  
  427.   if (s == NULL)
  428.     return Tkinter_Error (self);
  429.  
  430.   return PyString_FromString (s);
  431. }
  432.  
  433. static PyObject *
  434. Tkapp_GetVar (self, args)
  435.      PyObject *self;
  436.      PyObject *args;
  437. {
  438.   return GetVar (self, args, TCL_LEAVE_ERR_MSG);
  439. }
  440.  
  441. static PyObject *
  442. Tkapp_GlobalGetVar (self, args)
  443.      PyObject *self;
  444.      PyObject *args;
  445. {
  446.   return GetVar (self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
  447. }
  448.  
  449. static PyObject *
  450. UnsetVar (self, args, flags)
  451.      PyObject *self;
  452.      PyObject *args;
  453.      int flags;
  454. {
  455.   char *name1, *name2;
  456.   int code;
  457.  
  458.   if (PyArg_Parse (args, "s", &name1))
  459.     code = Tcl_UnsetVar (Tkapp_Interp (self), name1, flags);
  460.   else if (PyArg_Parse (args, "(ss)", &name1, &name2))
  461.     code = Tcl_UnsetVar2 (Tkapp_Interp (self), name1, name2, flags);
  462.   else
  463.     return NULL;
  464.  
  465.   if (code == TCL_ERROR)
  466.     return Tkinter_Error (self);
  467.  
  468.   Py_INCREF (Py_None);
  469.   return Py_None;
  470. }
  471.  
  472. static PyObject *
  473. Tkapp_UnsetVar (self, args)
  474.      PyObject *self;
  475.      PyObject *args;
  476. {
  477.   return UnsetVar (self, args, TCL_LEAVE_ERR_MSG);
  478. }
  479.  
  480. static PyObject *
  481. Tkapp_GlobalUnsetVar (self, args)
  482.      PyObject *self;
  483.      PyObject *args;
  484. {
  485.   return UnsetVar (self, args, TCL_LEAVE_ERR_MSG | TCL_GLOBAL_ONLY);
  486. }
  487.  
  488. /** Tcl to Python **/
  489.  
  490. static PyObject *
  491. Tkapp_GetInt (self, args)
  492.      PyObject *self;
  493.      PyObject *args;
  494. {
  495.   char *s;
  496.   int v;
  497.  
  498.   if (!PyArg_Parse (args, "s", &s))
  499.     return NULL;
  500.   if (Tcl_GetInt (Tkapp_Interp (self), s, &v) == TCL_ERROR)
  501.     return Tkinter_Error (self);
  502.   return Py_BuildValue ("i", v);
  503. }
  504.  
  505. static PyObject *
  506. Tkapp_GetDouble (self, args)
  507.      PyObject *self;
  508.      PyObject *args;
  509. {
  510.   char *s;
  511.   double v;
  512.  
  513.   if (!PyArg_Parse (args, "s", &s))
  514.     return NULL;
  515.   if (Tcl_GetDouble (Tkapp_Interp (self), s, &v) == TCL_ERROR)
  516.     return Tkinter_Error (self);
  517.   return Py_BuildValue ("d", v);
  518. }
  519.  
  520. static PyObject *
  521. Tkapp_GetBoolean (self, args)
  522.      PyObject *self;
  523.      PyObject *args;
  524. {
  525.   char *s;
  526.   int v;
  527.  
  528.   if (!PyArg_Parse (args, "s", &s))
  529.     return NULL;
  530.   if (Tcl_GetBoolean (Tkapp_Interp (self), s, &v) == TCL_ERROR)
  531.     return Tkinter_Error (self);
  532.   return Py_BuildValue ("i", v);
  533. }
  534.  
  535. static PyObject *
  536. Tkapp_ExprString (self, args)
  537.      PyObject *self;
  538.      PyObject *args;
  539. {
  540.   char *s;
  541.  
  542.   if (!PyArg_Parse (args, "s", &s))
  543.     return NULL;
  544.   if (Tcl_ExprString (Tkapp_Interp (self), s) == TCL_ERROR)
  545.     return Tkinter_Error (self);
  546.   return Py_BuildValue ("s", Tkapp_Result (self));
  547. }
  548.  
  549. static PyObject *
  550. Tkapp_ExprLong (self, args)
  551.      PyObject *self;
  552.      PyObject *args;
  553. {
  554.   char *s;
  555.   long v;
  556.  
  557.   if (!PyArg_Parse (args, "s", &s))
  558.     return NULL;
  559.   if (Tcl_ExprLong (Tkapp_Interp (self), s, &v) == TCL_ERROR)
  560.     return Tkinter_Error (self);
  561.   return Py_BuildValue ("l", v);
  562. }
  563.  
  564. static PyObject *
  565. Tkapp_ExprDouble (self, args)
  566.      PyObject *self;
  567.      PyObject *args;
  568. {
  569.   char *s;
  570.   double v;
  571.  
  572.   if (!PyArg_Parse (args, "s", &s))
  573.     return NULL;
  574.   if (Tcl_ExprDouble (Tkapp_Interp (self), s, &v) == TCL_ERROR)
  575.     return Tkinter_Error (self);
  576.   return Py_BuildValue ("d", v);
  577. }
  578.  
  579. static PyObject *
  580. Tkapp_ExprBoolean (self, args)
  581.      PyObject *self;
  582.      PyObject *args;
  583. {
  584.   char *s;
  585.   int v;
  586.  
  587.   if (!PyArg_Parse (args, "s", &s))
  588.     return NULL;
  589.   if (Tcl_ExprBoolean (Tkapp_Interp (self), s, &v) == TCL_ERROR)
  590.     return Tkinter_Error (self);
  591.   return Py_BuildValue ("i", v);
  592. }
  593.  
  594. static PyObject *
  595. Tkapp_SplitList (self, args)
  596.      PyObject *self;
  597.      PyObject *args;
  598. {
  599.   char *list;
  600.   int argc;
  601.   char **argv;
  602.   PyObject *v;
  603.   int i;
  604.  
  605.   if (!PyArg_Parse (args, "s", &list))
  606.     return NULL;
  607.  
  608.   if (Tcl_SplitList (Tkapp_Interp (self), list, &argc, &argv) == TCL_ERROR)
  609.     return Tkinter_Error (self);
  610.  
  611.   v = PyTuple_New (argc);
  612.   for (i = 0; i < argc; i++)
  613.     PyTuple_SetItem (v, i, PyString_FromString (argv[i]));
  614.  
  615.   free (argv);
  616.   return v;
  617. }
  618.  
  619. static PyObject *
  620. Tkapp_Split (self, args)
  621.      PyObject *self;
  622.      PyObject *args;
  623. {
  624.   char *list;
  625.  
  626.   if (!PyArg_Parse (args, "s", &list))
  627.     return NULL;
  628.   return Split (self, list);
  629. }
  630.  
  631. static PyObject *
  632. Tkapp_Merge (self, args)
  633.      PyObject *self;
  634.      PyObject *args;
  635. {
  636.   char *s;
  637.   PyObject *v;
  638.  
  639.   s = Merge (args);
  640.   v = PyString_FromString (s);
  641.   free (s);
  642.   return v;
  643. }
  644.  
  645. /** Tcl Command **/
  646.  
  647. /* This is the Tcl command that acts as a wrapper for Python
  648.    function or method.  */
  649. static int
  650. PythonCmd (clientData, interp, argc, argv)
  651.      ClientData clientData;    /* Is (self, func) */
  652.      Tcl_Interp *interp;
  653.      int argc;
  654.      char *argv[];
  655. {
  656.   PyObject *self, *func, *arg, *res, *tmp;
  657.   int i;
  658.  
  659.   self = PyTuple_GetItem ((PyObject *) clientData, 0);
  660.   func = PyTuple_GetItem ((PyObject *) clientData, 1);
  661.  
  662.   /* Create argument list (argv1, ..., argvN) */
  663.   arg = PyTuple_New (argc - 1);
  664.   for (i = 0; i < (argc - 1); i++)
  665.     PyTuple_SetItem (arg, i, PyString_FromString (argv[i + 1]));
  666.   
  667.   res = PyEval_CallObject (func, arg);
  668.   Py_DECREF (arg);
  669.  
  670.   if (res == NULL)
  671.     return PythonCmd_Error (interp);
  672.  
  673.   tmp = PyList_New (0);
  674.   Tcl_SetResult (Tkapp_Interp (self), AsString (res, tmp), TCL_VOLATILE);
  675.   Py_DECREF (res);
  676.   Py_DECREF (tmp);
  677.  
  678.   return TCL_OK;
  679. }
  680.  
  681. static void
  682. PythonCmdDelete (clientData)
  683.      ClientData clientData;    /* Is (self, func) */
  684. {
  685.   Py_DECREF ((PyObject *) clientData);
  686. }
  687.  
  688. static PyObject *
  689. Tkapp_CreateCommand (self, args)
  690.      PyObject *self;
  691.      PyObject *args;
  692. {
  693.   char *cmdName;
  694.   PyObject *data;
  695.   PyObject *func;
  696.   
  697.   /* Args is: (cmdName, func) */
  698.   if (!PyTuple_Check (args) 
  699.       || !(PyTuple_Size (args) == 2)
  700.       || !PyString_Check (PyTuple_GetItem (args, 0))
  701.       || !(PyMethod_Check (PyTuple_GetItem (args, 1)) 
  702.        || PyFunction_Check (PyTuple_GetItem (args, 1))))
  703.     {
  704.       PyErr_SetString (PyExc_TypeError, "bad argument list");
  705.       return NULL;
  706.     }
  707.  
  708.   cmdName = PyString_AsString (PyTuple_GetItem (args, 0));
  709.   func = PyTuple_GetItem (args, 1);
  710.  
  711.   data = PyTuple_New (2);   /* ClientData is: (self, func) */
  712.  
  713.   Py_INCREF (self);
  714.   PyTuple_SetItem (data, 0, self);
  715.  
  716.   Py_INCREF (func);
  717.   PyTuple_SetItem (data, 1, func);
  718.  
  719.   Tcl_CreateCommand (Tkapp_Interp (self), cmdName, PythonCmd,
  720.              (ClientData) data, PythonCmdDelete);
  721.  
  722.   Py_INCREF (Py_None);
  723.   return Py_None;
  724. }
  725.  
  726. static PyObject *
  727. Tkapp_DeleteCommand (self, args)
  728.      PyObject *self;
  729.      PyObject *args;
  730. {
  731.   char *cmdName;
  732.  
  733.   if (!PyArg_Parse (args, "s", &cmdName))
  734.     return NULL;
  735.   if (Tcl_DeleteCommand (Tkapp_Interp (self), cmdName) == -1)
  736.     {
  737.       PyErr_SetString (Tkinter_TclError, "can't delete Tcl command");
  738.       return NULL;
  739.     }
  740.   Py_INCREF (Py_None);
  741.   return Py_None;
  742. }
  743.  
  744. /** File Handler **/
  745.  
  746. void
  747. FileHandler (clientData, mask)
  748.      ClientData clientData;    /* Is: (func, file) */
  749.      int mask;
  750. {
  751.   PyObject *func, *file, *arg, *res;
  752.  
  753.   func = PyTuple_GetItem ((PyObject *) clientData, 0);
  754.   file = PyTuple_GetItem ((PyObject *) clientData, 1);
  755.  
  756.   arg = Py_BuildValue ("(Oi)", file, (long) mask);
  757.   res = PyEval_CallObject (func, arg);
  758.   Py_DECREF (arg);
  759.   if (res == NULL)
  760.     {
  761.       errorInCmd = 1;
  762.       PyErr_GetAndClear (&excInCmd, &valInCmd);
  763.     }
  764.   Py_XDECREF (res);
  765. }
  766.  
  767. static int
  768. GetFileNo (file)
  769.     PyObject *file; /* Either an int >= 0 or an object with a
  770.                .fileno() method that returns an int >= 0 */
  771. {
  772.     object *meth, *args, *res;
  773.     int id;
  774.     if (PyInt_Check(file)) {
  775.         id = PyInt_AsLong(file);
  776.         if (id < 0)
  777.             PyErr_SetString(PyExc_ValueError, "invalid file id");
  778.         return id;
  779.     }
  780.     meth = PyObject_GetAttrString(file, "fileno");
  781.     if (meth == NULL)
  782.         return -1;
  783.     args = PyTuple_New(0);
  784.     if (args == NULL)
  785.         return -1;
  786.     res = PyEval_CallObject(meth, args);
  787.     Py_DECREF(args);
  788.     Py_DECREF(meth);
  789.     if (res == NULL)
  790.         return -1;
  791.     if (PyInt_Check(res))
  792.         id = PyInt_AsLong(res);
  793.     else
  794.         id = -1;
  795.     if (id < 0)
  796.         PyErr_SetString(PyExc_ValueError,
  797.                 "invalid fileno() return value");
  798.     Py_DECREF(res);
  799.     return id;
  800. }
  801.  
  802. static PyObject *
  803. Tkapp_CreateFileHandler (self, args)
  804.      PyObject *self;
  805.      PyObject *args;        /* Is (file, mask, func) */
  806. {
  807.   PyObject *file, *func, *data;
  808.   int mask, id;
  809.  
  810.   if (!PyArg_Parse (args, "(OiO)", &file, &mask, &func))
  811.     return NULL;
  812.   id = GetFileNo (file);
  813.   if (id < 0)
  814.     return NULL;
  815.   if (!(PyMethod_Check(func) || PyFunction_Check(func)))
  816.     {
  817.       PyErr_SetString (PyExc_TypeError, "bad argument list");
  818.       return NULL;
  819.     }
  820.  
  821.   /* ClientData is: (func, file) */
  822.   data = Py_BuildValue ("(OO)", func, file);
  823.  
  824.   Tk_CreateFileHandler (id, mask, FileHandler, (ClientData) data);
  825.   /* XXX fileHandlerDict */
  826.  
  827.   Py_INCREF (Py_None);
  828.   return Py_None;
  829. }
  830.  
  831. static PyObject *
  832. Tkapp_DeleteFileHandler (self, args)
  833.      PyObject *self;
  834.      PyObject *args;        /* Args: file */
  835. {
  836.   PyObject *file;
  837.   int id;
  838.  
  839.   if (!PyArg_Parse (args, "O", &file))
  840.     return NULL;
  841.   id = GetFileNo (file);
  842.   if (id < 0)
  843.     return NULL;
  844.  
  845.   Tk_DeleteFileHandler (id);
  846.   /* XXX fileHandlerDict */
  847.   Py_INCREF (Py_None);
  848.   return Py_None;
  849. }
  850.  
  851. /** Event Loop **/
  852.  
  853. static PyObject *
  854. Tkapp_MainLoop (self, args)
  855.      PyObject *self;
  856.      PyObject *args;
  857. {
  858.   if (!PyArg_Parse (args, ""))
  859.     return NULL;
  860.  
  861.   quitMainLoop = 0;
  862.   while (tk_NumMainWindows > 0 && !quitMainLoop && !errorInCmd)
  863.     {
  864.       if (PyOS_InterruptOccurred ())
  865.     {
  866.       PyErr_SetNone (PyExc_KeyboardInterrupt);
  867.       return NULL;
  868.     }
  869.       Tk_DoOneEvent (0);
  870.     }
  871.  
  872.   if (errorInCmd)
  873.     {
  874.       errorInCmd = 0;
  875.       PyErr_SetObject (excInCmd, valInCmd);
  876.       return NULL;
  877.     }
  878.   Py_INCREF (Py_None);
  879.   return Py_None;
  880. }
  881.  
  882. static PyObject *
  883. Tkapp_Quit (self, args)
  884.      PyObject *self;
  885.      PyObject *args;
  886. {
  887.  
  888.   if (!PyArg_Parse (args, ""))
  889.     return NULL;
  890.   quitMainLoop = 1;
  891.   Py_INCREF (Py_None);
  892.   return Py_None;
  893. }
  894.  
  895. /**** Tkapp Method List ****/
  896.  
  897. static PyMethodDef Tkapp_methods[] =
  898. {
  899.   {"call", Tkapp_Call},
  900.   {"globalcall", Tkapp_GlobalCall},
  901.   {"eval", Tkapp_Eval},
  902.   {"globaleval", Tkapp_GlobalEval},
  903.   {"evalfile", Tkapp_EvalFile},
  904.   {"record", Tkapp_Record},
  905.   {"adderrorinfo", Tkapp_AddErrorInfo},
  906.   {"setvar", Tkapp_SetVar},
  907.   {"globalsetvar", Tkapp_GlobalSetVar},
  908.   {"getvar", Tkapp_GetVar},
  909.   {"globalgetvar", Tkapp_GlobalGetVar},
  910.   {"unsetvar", Tkapp_UnsetVar},
  911.   {"globalunsetvar", Tkapp_GlobalUnsetVar},
  912.   {"getint", Tkapp_GetInt},
  913.   {"getdouble", Tkapp_GetDouble},
  914.   {"getboolean", Tkapp_GetBoolean},
  915.   {"exprstring", Tkapp_ExprString},
  916.   {"exprlong", Tkapp_ExprLong},
  917.   {"exprdouble", Tkapp_ExprDouble},
  918.   {"exprboolean", Tkapp_ExprBoolean},
  919.   {"splitlist", Tkapp_SplitList},
  920.   {"split", Tkapp_Split},
  921.   {"merge", Tkapp_Merge},
  922.   {"createcommand", Tkapp_CreateCommand},
  923.   {"deletecommand", Tkapp_DeleteCommand},
  924.   {"createfilehandler", Tkapp_CreateFileHandler},
  925.   {"deletefilehandler", Tkapp_DeleteFileHandler},
  926.   {"mainloop", Tkapp_MainLoop},
  927.   {"quit", Tkapp_Quit},
  928.   {NULL, NULL}
  929. };
  930.  
  931. /**** Tkapp Type Methods ****/
  932.  
  933. static void
  934. Tkapp_Dealloc (self)
  935.      PyObject *self;
  936. {
  937.   Tk_DestroyWindow (Tkapp_Tkwin (self));
  938.   Tcl_DeleteInterp (Tkapp_Interp (self));
  939.   PyMem_DEL (self);
  940. }
  941.  
  942. static PyObject *
  943. Tkapp_GetAttr (self, name)
  944.      PyObject *self;
  945.      char *name;
  946. {
  947.   return Py_FindMethod (Tkapp_methods, self, name);
  948. }
  949.  
  950. static PyTypeObject Tkapp_Type =
  951. {
  952.   OB_HEAD_INIT (&PyType_Type)
  953.   0,                /*ob_size */
  954.   "tkapp",            /*tp_name */
  955.   sizeof (TkappObject),        /*tp_basicsize */
  956.   0,                /*tp_itemsize */
  957.   Tkapp_Dealloc,        /*tp_dealloc */
  958.   0,                /*tp_print */
  959.   Tkapp_GetAttr,        /*tp_getattr */
  960.   0,                /*tp_setattr */
  961.   0,                /*tp_compare */
  962.   0,                /*tp_repr */
  963.   0,                /*tp_as_number */
  964.   0,                /*tp_as_sequence */
  965.   0,                /*tp_as_mapping */
  966.   0,                /*tp_hash */
  967. };
  968.  
  969. /**** Tkinter Module ****/
  970.  
  971. static PyObject *
  972. Tkinter_Create (self, args)
  973.      PyObject *self;
  974.      PyObject *args;
  975. {
  976.   char *screenName = NULL;
  977.   char *baseName;
  978.   char *className;
  979.   int interactive = 0;
  980.  
  981.   baseName = strrchr (getprogramname (), '/');
  982.   if (baseName != NULL)
  983.     baseName++;
  984.   else
  985.     baseName = getprogramname ();
  986.   className = "Tk";
  987.   
  988.   if (PyArg_Parse (args, ""))
  989.     /* VOID */ ;
  990.   else if (PyArg_Parse (args, "z", 
  991.             &screenName))
  992.     /* VOID */ ;
  993.   else if (PyArg_Parse (args, "(zs)", 
  994.             &screenName, &baseName))
  995.     /* VOID */ ;
  996.   else if (PyArg_Parse (args, "(zss)", 
  997.             &screenName, &baseName, &className))
  998.     /* VOID */ ;
  999.   else if (PyArg_Parse (args, "(zssi)", 
  1000.             &screenName, &baseName, &className, &interactive))
  1001.     /* VOID */ ;
  1002.   else
  1003.     return NULL;
  1004.  
  1005.   return (PyObject *) Tkapp_New (screenName, baseName, className, 
  1006.                  interactive);
  1007. }
  1008.  
  1009. static PyMethodDef moduleMethods[] =
  1010. {
  1011.   {"create", Tkinter_Create},
  1012.   {NULL, NULL}
  1013. };
  1014.  
  1015. #ifdef WITH_READLINE
  1016. static int
  1017. EventHook ()
  1018. {
  1019.   if (errorInCmd)        /* XXX Reset tty */
  1020.     {
  1021.       errorInCmd = 0;
  1022.       PyErr_SetObject (excInCmd, valInCmd);
  1023.       PyErr_Print ();
  1024.      }
  1025.   if (tk_NumMainWindows > 0)
  1026.     Tk_DoOneEvent (TK_DONT_WAIT);
  1027.   return 0;
  1028. }
  1029. #endif /* WITH_READLINE */
  1030.  
  1031. static void
  1032. Tkinter_Cleanup ()
  1033. {
  1034.   /* XXX rl_deprep_terminal is static, damned! */
  1035.   while (tkMainWindowList != 0)
  1036.     Tk_DestroyWindow (tkMainWindowList->win);
  1037. }
  1038.  
  1039. void
  1040. PyInit_tkinter ()
  1041. {
  1042.   static inited = 0;
  1043.  
  1044. #ifdef WITH_READLINE
  1045.   extern int (*rl_event_hook) ();
  1046. #endif /* WITH_READLINE */
  1047.   PyObject *m, *d, *v;
  1048.  
  1049.   m = Py_InitModule ("tkinter", moduleMethods);
  1050.  
  1051.   d = PyModule_GetDict (m);
  1052.   Tkinter_TclError = Py_BuildValue ("s", "TclError");
  1053.   PyDict_SetItemString (d, "TclError", Tkinter_TclError);
  1054.  
  1055.   v = Py_BuildValue ("i", TK_READABLE);
  1056.   PyDict_SetItemString (d, "READABLE", v);
  1057.   v = Py_BuildValue ("i", TK_WRITABLE);
  1058.   PyDict_SetItemString (d, "WRITABLE", v);
  1059.   v = Py_BuildValue ("i", TK_EXCEPTION);
  1060.   PyDict_SetItemString (d, "EXCEPTION", v);
  1061.  
  1062. #ifdef WITH_READLINE
  1063.   rl_event_hook = EventHook;
  1064. #endif /* WITH_READLINE */
  1065.  
  1066.   if (!inited)
  1067.     {
  1068.       inited = 1;
  1069.       if (Py_AtExit (Tkinter_Cleanup) != 0)
  1070.     fprintf(stderr,
  1071.         "Tkinter: warning: cleanup procedure not registered\n");
  1072.     }
  1073.  
  1074.   if (PyErr_Occurred ())
  1075.     Py_FatalError ("can't initialize module tkinter");
  1076. }
  1077.