python.c

   1 /*--------------------------------------------------------------*/
   2 /* python.c --- Embedded python interpreter for xcircuit        */
   3 /* Copyright (c) 2002  Tim Edwards, Johns Hopkins University    */
   4 /*--------------------------------------------------------------*/
   5 /* NOTE: These routines work only if python-2.0 is installed.   */
   6 /*      Requires library file libpython2.0.a.  Hopefully        */
   7 /*      one day there will be a standard libpython${VERSION}.so */
   8 /*      so that the whole thing doesn't have to be linked       */
   9 /*      into the xcircuit executable. . .                       */
  10 /*                                                              */
  11 /*      Modeled after demo.c in Python2.0 source Demo/embed     */
  12 /*--------------------------------------------------------------*/
  13
  14 #if defined(HAVE_PYTHON) && !defined(TCL_WRAPPER)
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <unistd.h>     /* for usleep() */
  19 #include <string.h>
  20
  21 #include <Python.h>
  22
  23 #include <X11/Intrinsic.h>
  24 #include <X11/StringDefs.h>
  25 #include "Xw/Xw.h"
  26 #include "Xw/MenuBtn.h"
  27
  28 #ifdef HAVE_XPM
  29 #include <X11/xpm.h>
  30 #include "lib/pixmaps/q.xpm"
  31 #endif
  32
  33 PyObject *xcmod;
  34
  35 /*----------------------------------------------------------------------*/
  36 /* Local includes                                                       */
  37 /*----------------------------------------------------------------------*/
  38
  39 #include "xcircuit.h"
  40 #include "menudep.h"
  41 #include "colordefs.h"
  42
  43 /*----------------------------------------------------------------------*/
  44 /* Function prototype declarations                                      */
  45 /*----------------------------------------------------------------------*/
  46
  47 #include "prototypes.h"
  48
  49 static PyObject *xc_new(PyObject *, PyObject *);
  50 static PyObject *xc_set(PyObject *, PyObject *);
  51 static PyObject *xc_override(PyObject *, PyObject *);
  52 static PyObject *xc_library(PyObject *, PyObject *);
  53 static PyObject *xc_font(PyObject *, PyObject *);
  54 static PyObject *xc_color(PyObject *, PyObject *);
  55 static PyObject *xc_pause(PyObject *, PyObject *);
  56 static PyObject *xc_refresh(PyObject *, PyObject *);
  57 static PyObject *xc_bind(PyObject *, PyObject *);
  58 static PyObject *xc_unbind(PyObject *, PyObject *);
  59 static PyObject *xc_simplepopup(PyObject *, PyObject *);
  60 static PyObject *xc_popupprompt(PyObject *, PyObject *);
  61 static PyObject *xc_filepopup(PyObject *, PyObject *);
  62 static PyObject *xc_newbutton(PyObject *, PyObject *);
  63 static PyObject *xc_page(PyObject *, PyObject *);
  64 static PyObject *xc_load(PyObject *, PyObject *);
  65 static PyObject *xc_pan(PyObject *, PyObject *);
  66 static PyObject *xc_zoom(PyObject *, PyObject *);
  67 static PyObject *xc_getcursor();
  68 static PyObject *xc_getwindow();
  69 static PyObject *xc_reset();
  70 static PyObject *xc_netlist();
  71 #ifdef HAVE_XPM
  72 static PyObject *xc_newtool(PyObject *, PyObject *);
  73 #endif
  74
  75 int string_to_type(const char *);
  76
  77 /*----------------------------------------------------------------------*/
  78 /* External variable declarations                                       */
  79 /*----------------------------------------------------------------------*/
  80
  81 extern char _STR2[250], _STR[150];
  82 extern fontinfo *fonts;
  83 extern short fontcount;
  84 extern XCWindowData *areawin;
  85 extern Globaldata xobjs;
  86 extern short beeper;
  87 extern Widget menuwidgets[];
  88 extern Display *dpy;
  89 extern keybinding *keylist;
  90 extern int number_colors;
  91 extern colorindex *colorlist;
  92 extern ApplicationData appdata;
  93 #ifdef HAVE_XPM
  94 extern Widget toolbar;
  95 #endif
  96
  97 /*----------------------------------------------------------------------*/
  98
  99 short flags = -1;
 100
 101 #define LIBOVERRIDE     1
 102 #define LIBLOADED       2
 103 #define COLOROVERRIDE   4
 104 #define FONTOVERRIDE    8
 105 #define KEYOVERRIDE     16
 106
 107 /*----------------------------------------------------------------*/
 108 /* Similar to "PyRun_SimpleString()" but returns a PyObject value */
 109 /* rather than a status word.                                     */
 110 /*----------------------------------------------------------------*/
 111
 112 PyObject *PyRun_ObjString(char *string)
 113 {
 114    PyObject *m, *d, *v;
 115    m = PyImport_AddModule("__main__");
 116    if (m == NULL) return NULL;
 117    d = PyModule_GetDict(m);
 118    v = PyRun_String(string, Py_file_input, d, d);
 119    return v;
 120 }
 121
 122 /*--------------------------------------------------------------*/
 123 /* Define all of the xcircuit functions available to Python     */
 124 /* Currently this does the bare minimum of having Python do the */
 125 /* argument parsing; ideally, we would like to be doing more    */
 126 /* fundamental processing here.                                 */
 127 /*--------------------------------------------------------------*/
 128
 129 /*--------------------------------------------------------------*/
 130 /* Extract text from a popup and call the indicated python      */
 131 /* function.   If there is no text, function is called without  */
 132 /* arguments.                                                   */
 133 /*--------------------------------------------------------------*/
 134
 135 void pypromptvalue(Widget w, char *functionptr)
 136 {
 137    if (strlen(_STR2) == 0)
 138       sprintf(_STR, "%s()\n", functionptr);
 139    else
 140       sprintf(_STR, "%s('%s')\n", functionptr, _STR2);
 141
 142    PyRun_SimpleString(_STR);
 143    refresh(NULL, NULL, NULL);
 144 }
 145
 146 /*--------------------------------------------------------------*/
 147 /* Pop up a prompt, and return the value to the indicated       */
 148 /* python function.                                             */
 149 /*--------------------------------------------------------------*/
 150
 151 static PyObject *pypopupprompt(PyObject *self, PyObject *args,
 152         const char *dofile, char *displaystr)
 153 {
 154    const char *pfunction = NULL;
 155    const char *prompt = NULL;
 156    buttonsave *savebutton;
 157
 158    if (!PyArg_ParseTuple(args, "ss:popupprompt", &prompt, &pfunction))
 159       return PyInt_FromLong(-1L);
 160
 161
 162    savebutton = getgeneric(NULL, NULL, (void *)pfunction);
 163    popupprompt(areawin->area, (char *)prompt, displaystr,
 164                 pypromptvalue, savebutton, dofile);
 165
 166    return PyInt_FromLong(0L);
 167 }
 168
 169 /*--------------------------------------------------------------*/
 170 /* Wrappers for pypopuprompt()                                  */
 171 /*--------------------------------------------------------------*/
 172
 173 static PyObject *xc_popupprompt(PyObject *self, PyObject *args)
 174 {
 175    return pypopupprompt(self, args, NULL, "");
 176 }
 177
 178 static PyObject *xc_filepopup(PyObject *self, PyObject *args)
 179 {
 180    return pypopupprompt(self, args, "", "");
 181 }
 182
 183 static PyObject *xc_simplepopup(PyObject *self, PyObject *args)
 184 {
 185    _STR2[0] = '\0';
 186    return pypopupprompt(self, args, False, NULL);
 187 }
 188
 189 /*--------------------------------------------------------------*/
 190 /* Create objects and return a handle to that object in the     */
 191 /* form of a Python integer Object.                             */
 192 /*--------------------------------------------------------------*/
 193
 194 static PyObject *xc_new(PyObject *self, PyObject *args)
 195 {
 196    const char *etype;
 197    int type;
 198
 199    genericptr *newgen;
 200    arcptr *newarc;
 201    splineptr *newspline;
 202    polyptr *newpoly;
 203    labelptr *newlabel;
 204    pathptr *newpath;
 205    objinstptr *newobjinst;
 206
 207    if (!PyArg_ParseTuple(args, "s:newelement", &etype))
 208       return NULL;
 209
 210    switch(type = string_to_type(etype)) {
 211       case ARC:
 212          NEW_ARC(newarc, topobject);
 213          arcdefaults(*newarc, 0, 0);
 214          newgen = (genericptr *)newarc;
 215          break;
 216       case SPLINE:
 217          NEW_SPLINE(newspline, topobject);
 218          splinedefaults(*newspline, 0, 0);
 219          newgen = (genericptr *)newspline;
 220          break;
 221       case POLYGON:
 222          NEW_POLY(newpoly, topobject);
 223          polydefaults(*newpoly, 4, 0, 0);
 224          newgen = (genericptr *)newpoly;
 225          break;
 226       case LABEL:
 227          NEW_LABEL(newlabel, topobject);
 228          labeldefaults(*newlabel, 0, 0, 0);
 229          newgen = (genericptr *)newlabel;
 230          break;
 231       case PATH:
 232          NEW_PATH(newpath, topobject);
 233          pathdefaults(*newpath, 0, 0);
 234          newgen = (genericptr *)newpath;
 235          break;
 236       case OBJINST:
 237          NEW_OBJINST(newobjinst, topobject);
 238          instancedefaults(*newobjinst, NULL, 0, 0);
 239          newgen = (genericptr *)newobjinst;
 240          break;
 241       default:
 242          PyErr_SetString(PyExc_TypeError,
 243                 "newelement() 2nd argument must be a valid element type");
 244          return NULL;
 245    }
 246    incr_changes(topobject);
 247    invalidate_netlist(topobject);
 248
 249    return PyInt_FromLong((long)(*newgen));
 250 }
 251
 252 /*--------------------------------------------------------------*/
 253 /* Convert object type to a string                              */
 254 /*--------------------------------------------------------------*/
 255
 256 char *type_to_string(int type)
 257 {
 258    char *retstr = NULL;
 259
 260    switch(type) {
 261       case LABEL:
 262          retstr = malloc(6);
 263          strcpy(retstr, "Label");
 264          break;
 265       case POLYGON:
 266          retstr = malloc(8);
 267          strcpy(retstr, "Polygon");
 268          break;
 269       case SPLINE:
 270          retstr = malloc(12);
 271          strcpy(retstr, "Bezier Curve");
 272          break;
 273       case OBJINST:
 274          retstr = malloc(16);
 275          strcpy(retstr, "Object Instance");
 276          break;
 277       case PATH:
 278          retstr = malloc(5);
 279          strcpy(retstr, "Path");
 280          break;
 281       case ARC:
 282          retstr = malloc(4);
 283          strcpy(retstr, "Arc");
 284          break;
 285    }
 286    return retstr;
 287 }
 288
 289 /*--------------------------------------------------------------*/
 290 /* Convert a string to an element type                          */
 291 /*--------------------------------------------------------------*/
 292
 293 int string_to_type(const char *etype)
 294 {
 295    if (!strcmp(etype, "Arc"))
 296       return ARC;
 297    else if (!strcmp(etype, "Bezier Curve"))
 298       return SPLINE;
 299    else if (!strcmp(etype, "Polygon"))
 300       return POLYGON;
 301    else if (!strcmp(etype, "Label"))
 302       return LABEL;
 303    else if (!strcmp(etype, "Path"))
 304       return PATH;
 305    else if (!strcmp(etype, "Object Instance"))
 306       return OBJINST;
 307    else
 308       return -1;
 309 }
 310
 311 /*--------------------------------------------------------------*/
 312 /* Convert color index to 3-tuple and vice versa                */
 313 /* We assume that this color exists in the color table.         */
 314 /*--------------------------------------------------------------*/
 315
 316 PyObject *PyIndexToRGB(int cidx)
 317 {
 318    int i;
 319    PyObject *RGBTuple;
 320
 321    if (cidx < 0) {      /* Handle "default color" */
 322       return PyString_FromString("Default");
 323    }
 324
 325    for (i = 0; i < number_colors; i++) {
 326       if (cidx == colorlist[i].color.pixel) {
 327          RGBTuple = PyTuple_New(3);
 328          PyTuple_SetItem(RGBTuple, 0,
 329                 PyInt_FromLong((long)(colorlist[i].color.red / 256)));
 330          PyTuple_SetItem(RGBTuple, 1,
 331                 PyInt_FromLong((long)(colorlist[i].color.green / 256)));
 332          PyTuple_SetItem(RGBTuple, 2,
 333                 PyInt_FromLong((long)(colorlist[i].color.blue / 256)));
 334          return RGBTuple;
 335       }
 336    }
 337    PyErr_SetString(PyExc_TypeError, "invalid or unknown color index");
 338    return NULL;
 339 }
 340
 341 /*--------------------------------------------------------------*/
 342 /* Convert color 3-tuple (RGB) or name to a color index         */
 343 /*--------------------------------------------------------------*/
 344
 345 int PyRGBToIndex(PyObject *cobj)
 346 {
 347    PyObject *tobj;
 348    int ccolor, r, g, b;
 349
 350    if (PyTuple_Check(cobj) && PyTuple_Size(cobj) == 3) {  /* RGB 3-tuple */
 351       tobj = PyTuple_GetItem(cobj, 0);
 352       if (PyFloat_Check(tobj)) {
 353          r = (int)(65535 * (float)PyFloat_AsDouble(tobj));
 354          g = (int)(65535 * (float)PyFloat_AsDouble(PyTuple_GetItem(cobj, 1)));
 355          b = (int)(65535 * (float)PyFloat_AsDouble(PyTuple_GetItem(cobj, 2)));
 356       }
 357       else if (PyInt_Check(tobj)) {
 358          r = (int)(256 * PyInt_AsLong(tobj));
 359          g = (int)(256 * PyInt_AsLong(PyTuple_GetItem(cobj, 1)));
 360          b = (int)(256 * PyInt_AsLong(PyTuple_GetItem(cobj, 2)));
 361       }
 362       else {
 363          PyErr_SetString(PyExc_TypeError, "tuple components must be integer or float");
 364          return -1;
 365       }
 366       ccolor = rgb_alloccolor(r, g, b);
 367    }
 368    else if (PyString_Check(cobj)) {  /* color name */
 369       ccolor = xc_alloccolor(PyString_AsString(cobj));
 370    }
 371    else if (PyInt_Check(cobj)) {  /* index (for backward compatibility) */
 372       ccolor = (int)PyInt_AsLong(cobj);
 373    }
 374    else {
 375       PyErr_SetString(PyExc_TypeError, "argument must be a string or 3-tuple");
 376       return -1;
 377    }
 378
 379    addnewcolorentry(ccolor);
 380    return ccolor;
 381 }
 382
 383 /*--------------------------------------------------------------*/
 384 /* Convert a Python list to a stringpart*                       */
 385 /*--------------------------------------------------------------*/
 386
 387 stringpart *PySetStringParts(PyObject *dval)
 388 {
 389    PyObject *lstr, *litem, *ditem, *sitem, *titem;
 390    int i, j, llen;
 391    stringpart *strptr, *newpart;
 392    char *string;
 393
 394    /* If we pass a string, create a list of size 1 to hold the string.  */
 395    /* Otherwise, the argument must be a list.                           */
 396
 397    if (PyList_Check(dval)) {
 398       lstr = dval;
 399    }
 400    else {
 401       if (PyString_Check(dval)) {
 402          lstr = PyList_New(1);
 403          PyList_SetItem(lstr, 0, dval);
 404       }
 405       else {
 406          PyErr_SetString(PyExc_TypeError, "argument must be a string or a list");
 407          return NULL;
 408       }
 409    }
 410
 411    strptr = NULL;
 412    llen = PyList_Size(lstr);
 413    for (i = 0; i < llen; i++) {
 414       newpart = makesegment(&strptr, NULL);
 415       newpart->nextpart = NULL;
 416
 417       litem = PyList_GetItem(lstr, i);
 418       if (PyDict_Check(litem)) {
 419          if ((ditem = PyDict_GetItemString(litem, "Parameter")) != NULL) {
 420             newpart->type = PARAM_START;
 421             newpart->data.string = strdup(PyString_AsString(ditem));
 422          }
 423          else if ((ditem = PyDict_GetItemString(litem, "Font")) != NULL) {
 424             newpart->type = FONT_NAME;
 425             string = PyString_AsString(ditem);
 426             for (j = 0; j < fontcount; j++)
 427                if (!strcmp(fonts[j].psname, string)) break;
 428             if (j == fontcount) loadfontfile(string);
 429             newpart->data.font = j;
 430          }
 431          else if ((ditem = PyDict_GetItemString(litem, "Kern")) != NULL) {
 432             newpart->type = KERN;
 433             newpart->data.kern[0] = (int)PyInt_AsLong(PyTuple_GetItem(ditem, 0));
 434             newpart->data.kern[1] = (int)PyInt_AsLong(PyTuple_GetItem(ditem, 1));
 435          }
 436          else if ((ditem = PyDict_GetItemString(litem, "Color")) != NULL) {
 437             newpart->type = FONT_COLOR;
 438             newpart->data.color = PyRGBToIndex(ditem);
 439          }
 440          else if ((ditem = PyDict_GetItemString(litem, "Font Scale")) != NULL) {
 441             newpart->type = FONT_SCALE;
 442             newpart->data.scale = (float)PyFloat_AsDouble(ditem);
 443          }
 444          else if ((ditem = PyDict_GetItemString(litem, "Text")) != NULL) {
 445             newpart->type = TEXT_STRING;
 446             newpart->data.string = strdup(PyString_AsString(ditem));
 447          }
 448       }
 449       else if (PyString_Check(litem)) {
 450          string = PyString_AsString(litem);
 451          if (!strcmp(string, "End Parameter")) {
 452             newpart->type = PARAM_END;
 453             newpart->data.string = (u_char *)NULL;
 454          }
 455          else if (!strcmp(string, "Tab Stop")) {
 456             newpart->type = TABSTOP;
 457          }
 458          else if (!strcmp(string, "Tab Forward")) {
 459             newpart->type = TABFORWARD;
 460          }
 461          else if (!strcmp(string, "Tab Backward")) {
 462             newpart->type = TABBACKWARD;
 463          }
 464          else if (!strcmp(string, "Return")) {
 465             newpart->type = RETURN;
 466          }
 467          else if (!strcmp(string, "Subscript")) {
 468             newpart->type = SUBSCRIPT;
 469          }
 470          else if (!strcmp(string, "Superscript")) {
 471             newpart->type = SUPERSCRIPT;
 472          }
 473          else if (!strcmp(string, "Normalscript")) {
 474             newpart->type = NORMALSCRIPT;
 475          }
 476          else if (!strcmp(string, "Underline")) {
 477             newpart->type = UNDERLINE;
 478          }
 479          else if (!strcmp(string, "Overline")) {
 480             newpart->type = OVERLINE;
 481          }
 482          else if (!strcmp(string, "No Line")) {
 483             newpart->type = NOLINE;
 484          }
 485          else if (!strcmp(string, "Half Space")) {
 486             newpart->type = HALFSPACE;
 487          }
 488          else if (!strcmp(string, "Quarter Space")) {
 489             newpart->type = QTRSPACE;
 490          }
 491          else {
 492             newpart->type = TEXT_STRING;
 493             newpart->data.string = strdup(string);
 494          }
 495       }
 496    }
 497    return strptr;
 498 }
 499
 500 /*--------------------------------------------------------------*/
 501 /* Convert a stringpart* to a Python list                       */
 502 /*--------------------------------------------------------------*/
 503
 504 PyObject *PyGetStringParts(stringpart *thisstring)
 505 {
 506    PyObject *lstr, *sdict, *stup;
 507    int i, llen;
 508    stringpart *strptr;
 509
 510    llen = stringparts(thisstring);
 511    lstr = PyList_New(llen);
 512    for (strptr = thisstring, i = 0; strptr != NULL;
 513       strptr = strptr->nextpart, i++) {
 514       switch(strptr->type) {
 515          case TEXT_STRING:
 516             sdict = PyDict_New();
 517             PyDict_SetItem(sdict, PyString_FromString("Text"),
 518                   PyString_FromString(strptr->data.string));
 519             PyList_SetItem(lstr, i, sdict);
 520             break;
 521          case PARAM_START:
 522             sdict = PyDict_New();
 523             PyDict_SetItem(sdict, PyString_FromString("Parameter"),
 524                   PyString_FromString(strptr->data.string));
 525             PyList_SetItem(lstr, i, sdict);
 526             break;
 527          case PARAM_END:
 528             PyList_SetItem(lstr, i, PyString_FromString("End Parameter"));
 529             break;
 530          case FONT_NAME:
 531             sdict = PyDict_New();
 532             PyDict_SetItem(sdict, PyString_FromString("Font"),
 533                   PyString_FromString(fonts[strptr->data.font].psname));
 534             PyList_SetItem(lstr, i, sdict);
 535             break;
 536          case FONT_SCALE:
 537             sdict = PyDict_New();
 538             PyDict_SetItem(sdict, PyString_FromString("Font Scale"),
 539                   PyFloat_FromDouble((double)strptr->data.scale));
 540             PyList_SetItem(lstr, i, sdict);
 541             break;
 542          case KERN:
 543             sdict = PyDict_New();
 544             stup = PyTuple_New(2);
 545             PyTuple_SetItem(stup, 0, PyInt_FromLong((long)strptr->data.kern[0]));
 546             PyTuple_SetItem(stup, 1, PyInt_FromLong((long)strptr->data.kern[1]));
 547             PyDict_SetItem(sdict, PyString_FromString("Kern"), stup);
 548             PyList_SetItem(lstr, i, sdict);
 549             break;
 550          case FONT_COLOR:
 551             stup = PyIndexToRGB(strptr->data.color);
 552             if (stup != NULL) {
 553                sdict = PyDict_New();
 554                PyDict_SetItem(sdict, PyString_FromString("Color"), stup);
 555                PyList_SetItem(lstr, i, sdict);
 556             }
 557             break;
 558          case TABSTOP:
 559             PyList_SetItem(lstr, i, PyString_FromString("Tab Stop"));
 560             break;
 561          case TABFORWARD:
 562             PyList_SetItem(lstr, i, PyString_FromString("Tab Forward"));
 563             break;
 564          case TABBACKWARD:
 565             PyList_SetItem(lstr, i, PyString_FromString("Tab Backward"));
 566             break;
 567          case RETURN:
 568             PyList_SetItem(lstr, i, PyString_FromString("Return"));
 569             break;
 570          case SUBSCRIPT:
 571             PyList_SetItem(lstr, i, PyString_FromString("Subscript"));
 572             break;
 573          case SUPERSCRIPT:
 574             PyList_SetItem(lstr, i, PyString_FromString("Superscript"));
 575             break;
 576          case NORMALSCRIPT:
 577             PyList_SetItem(lstr, i, PyString_FromString("Normalscript"));
 578             break;
 579          case UNDERLINE:
 580             PyList_SetItem(lstr, i, PyString_FromString("Underline"));
 581             break;
 582          case OVERLINE:
 583             PyList_SetItem(lstr, i, PyString_FromString("Overline"));
 584             break;
 585          case NOLINE:
 586             PyList_SetItem(lstr, i, PyString_FromString("No Line"));
 587             break;
 588          case HALFSPACE:
 589             PyList_SetItem(lstr, i, PyString_FromString("Half Space"));
 590             break;
 591          case QTRSPACE:
 592             PyList_SetItem(lstr, i, PyString_FromString("Quarter Space"));
 593             break;
 594       }
 595    }
 596    return lstr;
 597 }
 598
 599 /*--------------------------------------------------------------*/
 600 /* Check if the handle (integer) is an existing element         */
 601 /*--------------------------------------------------------------*/
 602
 603 genericptr *CheckHandle(PyObject *ehandle)
 604 {
 605    genericptr *gelem;
 606    int i, j;
 607    long int eaddr;
 608    objectptr thisobj;
 609    Library *thislib;
 610
 611    eaddr = PyInt_AsLong(ehandle);
 612    for (gelem = topobject->plist; gelem < topobject->plist +
 613         topobject->parts; gelem++)
 614       if ((long int)(*gelem) == eaddr) goto exists;
 615
 616    /* Okay, it isn't in topobject.  Try all other pages. */
 617
 618    for (i = 0; i < xobjs.pages; i++) {
 619       if (xobjs.pagelist[i]->pageinst == NULL) continue;
 620       thisobj = xobjs.pagelist[i]->pageinst->thisobject;
 621       for (gelem = thisobj->plist; gelem < thisobj->plist + thisobj->parts; gelem++)
 622          if ((long int)(*gelem) == eaddr) goto exists;
 623    }
 624
 625    /* Still not found?  Maybe in a library */
 626
 627    for (i = 0; i < xobjs.numlibs; i++) {
 628       thislib = xobjs.userlibs + i;
 629       for (j = 0; j < thislib->number; j++) {
 630          thisobj = thislib->library[j];
 631          for (gelem = thisobj->plist; gelem < thisobj->plist + thisobj->parts; gelem++)
 632             if ((long int)(*gelem) == eaddr) goto exists;
 633       }
 634    }
 635
 636    /* Either in the delete list (where we don't want to go) or  */
 637    /* is an invalid number.                                     */
 638    return NULL;
 639
 640 exists:
 641    return gelem;
 642 }
 643
 644 /*--------------------------------------------------------------*/
 645 /* Check if the handle (integer) is an existing page            */
 646 /*--------------------------------------------------------------*/
 647
 648 objectptr CheckPageHandle(PyObject *ehandle)
 649 {
 650    int pageno;
 651    long int eaddr;
 652
 653    eaddr = PyInt_AsLong(ehandle);
 654    pageno = is_page((objectptr)eaddr);
 655    if (pageno < 0) return NULL;
 656    return (objectptr)eaddr;
 657 }
 658
 659 /*--------------------------------------------------------------*/
 660 /* Form a 2-tuple from a pair of integers.                      */
 661 /*--------------------------------------------------------------*/
 662
 663 static PyObject *make_pair(XPoint *thispoint)
 664 {
 665    PyObject *dtup;
 666
 667    dtup = PyTuple_New(2);
 668
 669    PyTuple_SetItem(dtup, 0,
 670                 PyInt_FromLong((long)(thispoint->x)));
 671    PyTuple_SetItem(dtup, 1,
 672                 PyInt_FromLong((long)(thispoint->y)));
 673    return dtup;
 674 }
 675
 676 /*--------------------------------------------------------------*/
 677 /* Get the properties of a page (returned as a dictionary)      */
 678 /*--------------------------------------------------------------*/
 679
 680 static PyObject *xc_getpage(PyObject *self, PyObject *args)
 681 {
 682    Pagedata *thispage;
 683    PyObject *rdict, *dlist;
 684    int pageno = areawin->page + 1, i;
 685
 686    if (!PyArg_ParseTuple(args, "|d:getpage", &pageno))
 687       return NULL;
 688
 689    if (pageno <= 0 || pageno > xobjs.pages) return NULL;
 690    else pageno--;
 691
 692    thispage = xobjs.pagelist[pageno];
 693
 694    rdict = PyDict_New();
 695
 696    PyDict_SetItem(rdict, PyString_FromString("filename"),
 697         PyString_FromString(thispage->filename));
 698
 699    PyDict_SetItem(rdict, PyString_FromString("page label"),
 700         PyString_FromString(thispage->pageinst->thisobject->name));
 701
 702    PyDict_SetItem(rdict, PyString_FromString("output scale"),
 703         PyFloat_FromDouble((double)thispage->outscale));
 704
 705    /* To be done:  change these from internal units to "natural" units */
 706
 707    PyDict_SetItem(rdict, PyString_FromString("grid space"),
 708         PyFloat_FromDouble((double)thispage->gridspace));
 709
 710    PyDict_SetItem(rdict, PyString_FromString("snap space"),
 711         PyFloat_FromDouble((double)thispage->snapspace));
 712
 713    PyDict_SetItem(rdict, PyString_FromString("orientation"),
 714         PyInt_FromLong((long)thispage->orient));
 715
 716    PyDict_SetItem(rdict, PyString_FromString("output mode"),
 717         PyInt_FromLong((long)thispage->pmode));
 718
 719    PyDict_SetItem(rdict, PyString_FromString("coordinate style"),
 720         PyInt_FromLong((long)thispage->coordstyle));
 721
 722    PyDict_SetItem(rdict, PyString_FromString("page size"),
 723         make_pair(&(thispage->pagesize)));
 724
 725    PyDict_SetItem(rdict, PyString_FromString("drawing scale"),
 726         make_pair(&(thispage->drawingscale)));
 727
 728    return rdict;
 729 }
 730
 731 /*--------------------------------------------------------------*/
 732 /* Get the properties of a library (returned as a dictionary)   */
 733 /*--------------------------------------------------------------*/
 734
 735 static PyObject *xc_getlibrary(PyObject *self, PyObject *args)
 736 {
 737    PyObject *rdict, *dlist;
 738    const char *lname = NULL;
 739    objectptr *curlib = NULL, thisobj;
 740    char *errptr;
 741    int i, lpage;
 742    int curobjs;
 743
 744    if (!PyArg_ParseTuple(args, "s:getlibrary", &lname))
 745       return NULL;
 746
 747    lpage = strtol(lname, &errptr, 10);
 748    if (*lname != '\0' && *errptr == '\0' && lpage <= xobjs.numlibs &&
 749                 lpage > 0) {    /* numerical */
 750       curlib = xobjs.userlibs[lpage - 1].library;
 751    }
 752    else {
 753       for (lpage = 0; lpage < xobjs.numlibs; lpage++) {
 754          if (!strcmp(lname, xobjs.libtop[lpage + LIBRARY]->thisobject->name)) {
 755             curlib = xobjs.userlibs[lpage - 1].library;
 756             break;
 757          }
 758          else if (!strncmp(xobjs.libtop[lpage + LIBRARY]->thisobject->name,
 759                         "Library: ", 9)) {
 760             if (!strcmp(lname, xobjs.libtop[lpage + LIBRARY]->thisobject->name + 9)) {
 761                curlib = xobjs.userlibs[lpage - 1].library;
 762                break;
 763             }
 764          }
 765       }
 766    }
 767
 768    if (curlib == NULL) {
 769       PyErr_SetString(PyExc_TypeError,
 770                 "getlibrary() 2nd argument must be a library page or name");
 771       return NULL;
 772    }
 773    curobjs = xobjs.userlibs[lpage - 1].number;
 774
 775    /* Argument to getlibrary() can be a library name or library page # */
 776
 777    rdict = PyDict_New();
 778
 779    PyDict_SetItem(rdict, PyString_FromString("name"),
 780         PyString_FromString(xobjs.libtop[lpage + LIBRARY]->thisobject->name));
 781
 782    if (curobjs > 0) {
 783       dlist = PyList_New(curobjs);
 784       for (i = 0; i < curobjs; i++) {
 785          thisobj = *(curlib + i);
 786          PyList_SetItem(dlist, i, PyString_FromString(thisobj->name));
 787       }
 788       PyDict_SetItem(rdict, PyString_FromString("objects"), dlist);
 789    }
 790    return rdict;
 791 }
 792
 793 /*--------------------------------------------------------------*/
 794 /* Get the properties of an object (returned as a dictionary)   */
 795 /*--------------------------------------------------------------*/
 796
 797 static PyObject *xc_getobject(PyObject *self, PyObject *args)
 798 {
 799    objectptr thisobj = NULL, *libobj;
 800    oparamptr ops;
 801    PyObject *rdict, *dlist, *tpos;
 802    const char *oname;
 803    int i, j, k, nparam;
 804
 805    if (!PyArg_ParseTuple(args, "s:getobject", &oname))
 806       return NULL;
 807
 808    for (k = 0; k < xobjs.numlibs; k++) {
 809       for (j = 0; j < xobjs.userlibs[k].number; j++) {
 810          libobj = xobjs.userlibs[k].library + j;
 811          if (!strcmp(oname, (*libobj)->name)) {
 812             thisobj = *libobj;
 813             break;
 814          }
 815       }
 816       if (thisobj != NULL) break;
 817    }
 818
 819    if (thisobj == NULL) {       /* try the page objects */
 820       for (k = 0; k < xobjs.pages; k++) {
 821          if (xobjs.pagelist[k]->pageinst != NULL)
 822             if (!strcmp(oname, xobjs.pagelist[k]->pageinst->thisobject->name))
 823                break;
 824       }
 825       if (k == xobjs.pages) return NULL;        /* not found */
 826    }
 827
 828    /* return all the object's properties as a dictionary */
 829
 830    rdict = PyDict_New();
 831
 832    PyDict_SetItem(rdict, PyString_FromString("name"),
 833         PyString_FromString(thisobj->name));
 834    PyDict_SetItem(rdict, PyString_FromString("width"),
 835         PyInt_FromLong((long)(thisobj->bbox.width)));
 836    PyDict_SetItem(rdict, PyString_FromString("height"),
 837         PyInt_FromLong((long)(thisobj->bbox.height)));
 838    PyDict_SetItem(rdict, PyString_FromString("viewscale"),
 839         PyFloat_FromDouble((double)(thisobj->viewscale)));
 840
 841    tpos = PyTuple_New(2);
 842    PyTuple_SetItem(tpos, 0, PyInt_FromLong((long)thisobj->bbox.lowerleft.x));
 843    PyTuple_SetItem(tpos, 1, PyInt_FromLong((long)thisobj->bbox.lowerleft.y));
 844    PyDict_SetItem(rdict, PyString_FromString("boundingbox"), tpos);
 845
 846    tpos = PyTuple_New(2);
 847    PyTuple_SetItem(tpos, 0, PyInt_FromLong((long)thisobj->pcorner.x));
 848    PyTuple_SetItem(tpos, 1, PyInt_FromLong((long)thisobj->pcorner.y));
 849    PyDict_SetItem(rdict, PyString_FromString("viewcorner"), tpos);
 850
 851    dlist = PyList_New(thisobj->parts);
 852    for (i = 0; i < thisobj->parts; i++)
 853       PyList_SetItem(dlist, i, PyInt_FromLong((long)(*(thisobj->plist + i))));
 854    PyDict_SetItem(rdict, PyString_FromString("parts"), dlist);
 855
 856    nparam = get_num_params(thisobj);
 857    if (nparam > 0) {
 858       dlist = PyList_New(nparam);
 859       i = 0;
 860       for (ops = thisobj->params; ops != NULL; ops = ops->next) {
 861          i++;
 862          if (ops->type == XC_INT)
 863             PyList_SetItem(dlist, i, PyInt_FromLong((long)(ops->parameter.ivalue)));
 864          else if (ops->type == XC_FLOAT)
 865             PyList_SetItem(dlist, i,
 866                 PyFloat_FromDouble((double)(ops->parameter.fvalue)));
 867          else if (ops->type == XC_STRING)
 868             PyList_SetItem(dlist, i, PyGetStringParts(ops->parameter.string));
 869       }
 870       PyDict_SetItem(rdict, PyString_FromString("parameters"), dlist);
 871    }
 872    return rdict;
 873 }
 874
 875 /*--------------------------------------------------------------*/
 876 /* Reset the current page                                       */
 877 /*--------------------------------------------------------------*/
 878
 879 static PyObject *xc_reset()
 880 {
 881    resetbutton(NULL, (pointertype)0, NULL);
 882    return PyInt_FromLong(0L);
 883 }
 884
 885 /*--------------------------------------------------------------*/
 886 /* Get a netlist                                                */
 887 /*--------------------------------------------------------------*/
 888
 889 extern PyObject *pyglobals(objectptr);
 890 extern PyObject *pytoplevel(objectptr);
 891
 892 static PyObject *xc_netlist()
 893 {
 894    PyObject *rdict = NULL;
 895
 896    if (updatenets(areawin->topinstance, FALSE) <= 0) {
 897       PyErr_SetString(PyExc_TypeError, "Error:  Check circuit for infinite recursion.");
 898       return NULL;
 899    }
 900
 901    rdict = PyDict_New();
 902    PyDict_SetItem(rdict, PyString_FromString("globals"), pyglobals(topobject));
 903    PyDict_SetItem(rdict, PyString_FromString("circuit"), pytoplevel(topobject));
 904    return rdict;
 905 }
 906
 907 /*--------------------------------------------------------------*/
 908 /* Load the specified file                                      */
 909 /*--------------------------------------------------------------*/
 910
 911 static PyObject *xc_load(PyObject *self, PyObject *args)
 912 {
 913    char *filename;
 914    int pageno = 0, savepage;
 915
 916    if (!PyArg_ParseTuple(args, "s|i:load", &filename, &pageno))
 917       return PyInt_FromLong((long)areawin->page);
 918
 919    if (--pageno < 0) pageno = areawin->page;
 920    savepage = areawin->page;
 921
 922    strcpy(_STR2, filename);
 923    if (savepage != pageno) newpage(pageno);
 924    startloadfile(-1);
 925    if (savepage != pageno) newpage(savepage);
 926
 927    return PyString_FromString(filename);
 928 }
 929
 930 /*--------------------------------------------------------------*/
 931 /* Go to the specified page                                     */
 932 /*--------------------------------------------------------------*/
 933
 934 static PyObject *xc_page(PyObject *self, PyObject *args)
 935 {
 936    int pageno;
 937
 938    if (!PyArg_ParseTuple(args, "i:page", &pageno))
 939       return PyInt_FromLong((long)areawin->page);
 940
 941    newpage(pageno - 1);
 942    return PyInt_FromLong((long)pageno);
 943 }
 944
 945 /*--------------------------------------------------------------*/
 946 /* Zoom                                                         */
 947 /*--------------------------------------------------------------*/
 948
 949 static PyObject *xc_zoom(PyObject *self, PyObject *args)
 950 {
 951    float factor, save;
 952
 953    if (!PyArg_ParseTuple(args, "f:zoom", &factor))
 954       return NULL;
 955
 956    if (factor <= 0) {
 957       PyErr_SetString(PyExc_TypeError, "Argument must be positive.");
 958       return NULL;
 959    }
 960
 961    save = areawin->zoomfactor;
 962
 963    if (factor < 1.0) {
 964       areawin->zoomfactor = 1.0 / factor;
 965       zoomout(0, 0);    /* Needs to be fixed---give x, y for drag fn */
 966    }
 967    else {
 968       areawin->zoomfactor = factor;
 969       zoomin(0, 0);     /* Needs to be fixed---see above */
 970    }
 971
 972    areawin->zoomfactor = save;
 973    return PyFloat_FromDouble((double)topobject->viewscale);
 974 }
 975
 976 /*--------------------------------------------------------------*/
 977 /* Pan                                                          */
 978 /*--------------------------------------------------------------*/
 979
 980 static PyObject *xc_pan(PyObject *self, PyObject *args)
 981 {
 982    PyObject *cornerpos, *xobj, *yobj = NULL, *pval;
 983    int x, y;
 984    XPoint upoint, wpoint;
 985
 986    if (!PyArg_ParseTuple(args, "O|O:pan", &xobj, &yobj))
 987       return NULL;
 988
 989    if (yobj == NULL) {
 990       if (PyTuple_Check(xobj) && PyTuple_Size(xobj) == 2) {
 991          if ((pval = PyTuple_GetItem(xobj, 0)) != NULL)
 992             upoint.x = PyInt_AsLong(pval);
 993          if ((pval = PyTuple_GetItem(xobj, 1)) != NULL)
 994             upoint.y = PyInt_AsLong(pval);
 995       }
 996       else return NULL;
 997    }
 998    else {
 999       upoint.x = PyInt_AsLong(xobj);
1000       upoint.y = PyInt_AsLong(yobj);
1001    }
1002
1003    user_to_window(upoint, &wpoint);
1004    panbutton((u_int)5, wpoint.x, wpoint.y, 0.33);  /* fixed fraction */
1005
1006    cornerpos = PyTuple_New(2);
1007    PyTuple_SetItem(cornerpos, 0, PyInt_FromLong((long)areawin->pcorner.x));
1008    PyTuple_SetItem(cornerpos, 1, PyInt_FromLong((long)areawin->pcorner.y));
1009
1010    return cornerpos;
1011 }
1012
1013 /*--------------------------------------------------------------*/
1014 /* Get the window size                                          */
1015 /*--------------------------------------------------------------*/
1016
1017 static PyObject *xc_getwindow()
1018 {
1019    PyObject *windowsize;
1020
1021    windowsize = PyTuple_New(2);
1022    PyTuple_SetItem(windowsize, 0, PyInt_FromLong((long)areawin->width));
1023    PyTuple_SetItem(windowsize, 1, PyInt_FromLong((long)areawin->height));
1024
1025    return windowsize;
1026 }
1027
1028 /*--------------------------------------------------------------*/
1029 /* Get the cursor position                                      */
1030 /*--------------------------------------------------------------*/
1031
1032 static PyObject *xc_getcursor()
1033 {
1034    PyObject *cursorpos;
1035    XPoint newpos;
1036
1037    newpos = UGetCursorPos();
1038    u2u_snap(&newpos);
1039
1040    cursorpos = PyTuple_New(2);
1041    PyTuple_SetItem(cursorpos, 0, PyInt_FromLong((long)newpos.x));
1042    PyTuple_SetItem(cursorpos, 1, PyInt_FromLong((long)newpos.y));
1043
1044    return cursorpos;
1045 }
1046
1047 /*--------------------------------------------------------------*/
1048 /* Get the properties of an element (returned as a dictionary)  */
1049 /*--------------------------------------------------------------*/
1050
1051 static PyObject *xc_getattr(PyObject *self, PyObject *args)
1052 {
1053    genericptr *gelem;
1054    PyObject *ehandle, *rdict, *dlist, *lstr, *sdict, *stup;
1055    int i, llen;
1056    char *tstr;
1057    stringpart *strptr;
1058
1059
1060    if (!PyArg_ParseTuple(args, "O:getattr", &ehandle))
1061       return NULL;
1062
1063    /* Check to make sure that handle exists! */
1064    if ((gelem = CheckHandle(ehandle)) == NULL) {
1065       PyErr_SetString(PyExc_TypeError,
1066                 "Argument must be a valid handle to an element.");
1067       return NULL;
1068    }
1069
1070    /* return the element's properties as a dictionary   */
1071
1072    rdict = PyDict_New();
1073    tstr = type_to_string((*gelem)->type);
1074    if (tstr == NULL) {
1075       PyErr_SetString(PyExc_TypeError,
1076                 "Element type is unknown.");
1077       return NULL;
1078    }
1079    PyDict_SetItem(rdict, PyString_FromString("type"),
1080         PyString_FromString(tstr));
1081    free(tstr);
1082    lstr = PyIndexToRGB((*gelem)->color);
1083    if (lstr != NULL)
1084       PyDict_SetItem(rdict, PyString_FromString("color"), lstr);
1085
1086    switch(ELEMENTTYPE(*gelem)) {
1087       case LABEL:
1088          PyDict_SetItem(rdict, PyString_FromString("position"),
1089                 make_pair(&(TOLABEL(gelem)->position)));
1090          PyDict_SetItem(rdict, PyString_FromString("rotation"),
1091                 PyFloat_FromDouble((double)TOLABEL(gelem)->rotation));
1092          PyDict_SetItem(rdict, PyString_FromString("scale"),
1093                 PyFloat_FromDouble((double)TOLABEL(gelem)->scale));
1094          PyDict_SetItem(rdict, PyString_FromString("anchor"),
1095                 PyInt_FromLong((long)TOLABEL(gelem)->anchor));
1096          PyDict_SetItem(rdict, PyString_FromString("pin"),
1097                 PyInt_FromLong((long)TOLABEL(gelem)->pin));
1098          lstr = PyGetStringParts(TOLABEL(gelem)->string);
1099
1100          PyDict_SetItem(rdict, PyString_FromString("string"), lstr);
1101          break;
1102       case POLYGON:
1103          PyDict_SetItem(rdict, PyString_FromString("style"),
1104                 PyInt_FromLong((long)TOPOLY(gelem)->style));
1105          PyDict_SetItem(rdict, PyString_FromString("linewidth"),
1106                 PyFloat_FromDouble((double)TOPOLY(gelem)->width));
1107          dlist = PyList_New(TOPOLY(gelem)->number);
1108          for (i = 0; i < TOPOLY(gelem)->number; i++) {
1109             PyList_SetItem(dlist, i, make_pair(&(TOPOLY(gelem)->points[i])));
1110          }
1111          PyDict_SetItem(rdict, PyString_FromString("points"), dlist);
1112          break;
1113       case ARC:
1114          PyDict_SetItem(rdict, PyString_FromString("style"),
1115                 PyInt_FromLong((long)TOARC(gelem)->style));
1116          PyDict_SetItem(rdict, PyString_FromString("linewidth"),
1117                 PyFloat_FromDouble((double)TOARC(gelem)->width));
1118          PyDict_SetItem(rdict, PyString_FromString("radius"),
1119                 PyInt_FromLong((long)TOARC(gelem)->radius));
1120          PyDict_SetItem(rdict, PyString_FromString("minor axis"),
1121                 PyInt_FromLong((long)TOARC(gelem)->yaxis));
1122          PyDict_SetItem(rdict, PyString_FromString("start angle"),
1123                 PyFloat_FromDouble((double)TOARC(gelem)->angle1));
1124          PyDict_SetItem(rdict, PyString_FromString("end angle"),
1125                 PyFloat_FromDouble((double)TOARC(gelem)->angle2));
1126          PyDict_SetItem(rdict, PyString_FromString("position"),
1127                 make_pair(&(TOARC(gelem)->position)));
1128          break;
1129       case SPLINE:
1130          PyDict_SetItem(rdict, PyString_FromString("style"),
1131                 PyInt_FromLong((long)TOSPLINE(gelem)->style));
1132          PyDict_SetItem(rdict, PyString_FromString("linewidth"),
1133                 PyFloat_FromDouble((double)TOSPLINE(gelem)->width));
1134          dlist = PyList_New(4);
1135          for (i = 0; i < 4; i++) {
1136             PyList_SetItem(dlist, i, make_pair(&(TOSPLINE(gelem)->ctrl[i])));
1137          }
1138          PyDict_SetItem(rdict, PyString_FromString("control points"), dlist);
1139          break;
1140       case PATH:
1141          PyDict_SetItem(rdict, PyString_FromString("style"),
1142                 PyInt_FromLong((long)TOPATH(gelem)->style));
1143          PyDict_SetItem(rdict, PyString_FromString("linewidth"),
1144                 PyFloat_FromDouble((double)TOPATH(gelem)->width));
1145          dlist = PyList_New(TOPATH(gelem)->parts);
1146          for (i = 0; i < TOPATH(gelem)->parts; i++) {
1147             PyList_SetItem(dlist, i,
1148                 PyInt_FromLong((long)(*(TOPATH(gelem)->plist + i))));
1149          }
1150          PyDict_SetItem(rdict, PyString_FromString("parts"), dlist);
1151          break;
1152       case OBJINST:
1153          PyDict_SetItem(rdict, PyString_FromString("position"),
1154                 make_pair(&(TOOBJINST(gelem)->position)));
1155          PyDict_SetItem(rdict, PyString_FromString("rotation"),
1156                 PyFloat_FromDouble((double)TOOBJINST(gelem)->rotation));
1157          PyDict_SetItem(rdict, PyString_FromString("scale"),
1158                 PyFloat_FromDouble((double)TOOBJINST(gelem)->scale));
1159          PyDict_SetItem(rdict, PyString_FromString("name"),
1160                 PyString_FromString(TOOBJINST(gelem)->thisobject->name));
1161          break;
1162    }
1163    return rdict;
1164 }
1165
1166 /*--------------------------------------------------------------*/
1167 /* Set properties of an element (supplied as a dictionary)      */
1168 /*--------------------------------------------------------------*/
1169
1170 static PyObject *xc_setattr(PyObject *self, PyObject *args)
1171 {
1172    genericptr *gelem;
1173    PyObject *ehandle, *attrdict, *dval, *pval, *qval;
1174    int i;
1175
1176    if (!PyArg_ParseTuple(args, "OO:setattr", &ehandle, &attrdict))
1177       return NULL;
1178
1179    /* Check to make sure that handle exists! */
1180    if ((gelem = CheckHandle(ehandle)) == NULL) return NULL;
1181
1182    /* Is the argument a dictionary? */
1183    if (!PyDict_Check(attrdict)) {
1184       PyErr_SetString(PyExc_TypeError,
1185                 "setatrr() 2nd argument must be a dictionary");
1186       return NULL;
1187    }
1188
1189    /* First, make sure no attempt is made to change the object type. */
1190
1191    if ((dval = PyDict_GetItemString(attrdict, "type")) != NULL) {
1192       int dtype = string_to_type(PyString_AsString(dval));
1193       if (dtype < 0) return NULL;
1194       if (dtype != ELEMENTTYPE(*gelem)) {
1195          PyErr_SetString(PyExc_TypeError,
1196                 "Attempt to change the type of an object.");
1197          return NULL;
1198       }
1199    }
1200
1201    /* Next, look for dictionary strings containing values which apply */
1202    /* to a number of different elements (position, color, etc.)       */
1203
1204    if ((dval = PyDict_GetItemString(attrdict, "color")) != NULL) {
1205       (*gelem)->color = (short)PyRGBToIndex(dval);
1206    }
1207
1208    if ((dval = PyDict_GetItemString(attrdict, "position")) != NULL) {
1209       if (PyTuple_Check(dval) && PyTuple_Size(dval) == 2) {
1210          if ((pval = PyTuple_GetItem(dval, 0)) != NULL) {
1211             short xpos = (short)PyInt_AsLong(pval);
1212             switch(ELEMENTTYPE(*gelem)) {
1213                case ARC:
1214                   TOARC(gelem)->position.x = xpos;
1215                   calcarc(TOARC(gelem));
1216                   break;
1217                case LABEL:
1218                   TOLABEL(gelem)->position.x = xpos;
1219                   break;
1220                case OBJINST:
1221                   TOOBJINST(gelem)->position.x = xpos;
1222                   break;
1223                default:
1224                   PyErr_SetString(PyExc_TypeError,
1225                       "attempt to set position on Spline, Polygon, or Path");
1226             }
1227          }
1228
1229          if ((pval = PyTuple_GetItem(dval, 1)) != NULL) {
1230             short ypos = (short)PyInt_AsLong(pval);
1231             switch(ELEMENTTYPE(*gelem)) {
1232                case ARC:
1233                   TOARC(gelem)->position.y = ypos;
1234                   calcarc(TOARC(gelem));
1235                   break;
1236                case LABEL:
1237                   TOLABEL(gelem)->position.y = ypos;
1238                   break;
1239                case OBJINST:
1240                   TOOBJINST(gelem)->position.y = ypos;
1241                   break;
1242                default:
1243                   PyErr_SetString(PyExc_TypeError,
1244                       "attempt to set position on Spline, Polygon, or Path");
1245             }
1246          }
1247       }
1248       else {
1249          PyErr_SetString(PyExc_TypeError,
1250                 "position must be a tuple containing two integer values");
1251       }
1252    }
1253
1254    if ((dval = PyDict_GetItemString(attrdict, "style")) != NULL) {
1255       short dstyle = (short)PyInt_AsLong(dval);
1256       switch(ELEMENTTYPE(*gelem)) {
1257          case POLYGON:
1258             TOPOLY(gelem)->style = dstyle;
1259             break;
1260          case PATH:
1261             TOPATH(gelem)->style = dstyle;
1262             break;
1263          case ARC:
1264             TOARC(gelem)->style = dstyle;
1265             break;
1266          case SPLINE:
1267             TOSPLINE(gelem)->style = dstyle;
1268             break;
1269          default:
1270             PyErr_SetString(PyExc_TypeError,
1271                 "attempt to set style on an Object Instance or Label");
1272       }
1273    }
1274
1275    if ((dval = PyDict_GetItemString(attrdict, "linewidth")) != NULL) {
1276       float dwidth = (float)PyFloat_AsDouble(dval);
1277       switch(ELEMENTTYPE(*gelem)) {
1278          case POLYGON:
1279             TOPOLY(gelem)->width = dwidth;
1280             break;
1281          case PATH:
1282             TOPATH(gelem)->width = dwidth;
1283             break;
1284          case ARC:
1285             TOARC(gelem)->width = dwidth;
1286             break;
1287          case SPLINE:
1288             TOSPLINE(gelem)->width = dwidth;
1289             break;
1290          default:
1291             PyErr_SetString(PyExc_TypeError,
1292                 "attempt to set linewidth on an Object Instance or Label");
1293       }
1294    }
1295
1296    if ((dval = PyDict_GetItemString(attrdict, "scale")) != NULL) {
1297       float dscale = (float)PyFloat_AsDouble(dval);
1298       switch(ELEMENTTYPE(*gelem)) {
1299          case LABEL:
1300             TOLABEL(gelem)->scale = dscale;
1301             break;
1302          case OBJINST:
1303             TOOBJINST(gelem)->scale = dscale;
1304             break;
1305          default:
1306             PyErr_SetString(PyExc_TypeError,
1307                 "attempt to set scale on something not a Label or Object Instance");
1308       }
1309    }
1310
1311    if ((dval = PyDict_GetItemString(attrdict, "rotation")) != NULL) {
1312       float drot = (float)PyFloat_AsDouble(dval);
1313       switch(ELEMENTTYPE(*gelem)) {
1314          case LABEL:
1315             TOLABEL(gelem)->rotation = drot;
1316             break;
1317          case OBJINST:
1318             TOOBJINST(gelem)->rotation = drot;
1319             break;
1320          default:
1321             PyErr_SetString(PyExc_TypeError,
1322                 "attempt to set rotation on something not a Label or Object Instance");
1323       }
1324    }
1325
1326    /* Dictionary entries specific to certain xcircuit types */
1327
1328    switch(ELEMENTTYPE(*gelem)) {
1329       case LABEL:
1330          if ((dval = PyDict_GetItemString(attrdict, "anchor")) != NULL) {
1331             TOLABEL(gelem)->anchor = PyInt_AsLong(dval);
1332          }
1333          if ((dval = PyDict_GetItemString(attrdict, "string")) != NULL) {
1334             freelabel(TOLABEL(gelem)->string);
1335             TOLABEL(gelem)->string = PySetStringParts(dval);
1336          }
1337          if ((dval = PyDict_GetItemString(attrdict, "pin")) != NULL) {
1338             TOLABEL(gelem)->pin = PyInt_AsLong(dval);
1339          }
1340          break;
1341       case ARC:
1342          if ((dval = PyDict_GetItemString(attrdict, "start angle")) != NULL) {
1343             TOARC(gelem)->angle1 = (float)PyFloat_AsDouble(dval);
1344          }
1345          if ((dval = PyDict_GetItemString(attrdict, "end angle")) != NULL) {
1346             TOARC(gelem)->angle2 = (float)PyFloat_AsDouble(dval);
1347          }
1348          if ((dval = PyDict_GetItemString(attrdict, "radius")) != NULL) {
1349             TOARC(gelem)->radius = PyInt_AsLong(dval);
1350          }
1351          if ((dval = PyDict_GetItemString(attrdict, "minor axis")) != NULL) {
1352             TOARC(gelem)->yaxis = PyInt_AsLong(dval);
1353          }
1354          break;
1355       case SPLINE:
1356          if ((dval = PyDict_GetItemString(attrdict, "control points")) != NULL) {
1357             if (PyList_Check(dval) && PyList_Size(dval) == 4) {
1358                for (i = 0; i < 4; i++) {
1359                   pval = PyList_GetItem(dval, i);
1360                   if (PyTuple_Check(pval) && PyTuple_Size(pval) == 2) {
1361                      qval = PyTuple_GetItem(pval, 0);
1362                      TOSPLINE(gelem)->ctrl[i].x = (short)PyInt_AsLong(qval);
1363                      qval = PyTuple_GetItem(pval, 1);
1364                      TOSPLINE(gelem)->ctrl[i].y = (short)PyInt_AsLong(qval);
1365                   }
1366                   else {
1367                      PyErr_SetString(PyExc_TypeError,
1368                                 "must have a tuple of 2 values per point");
1369                      break;
1370                   }
1371                }
1372             }
1373             else {
1374                PyErr_SetString(PyExc_TypeError,
1375                         "must have 4 control points in a list");
1376                break;
1377             }
1378          }
1379          break;
1380       case POLYGON:
1381          if ((dval = PyDict_GetItemString(attrdict, "points")) != NULL) {
1382             if (PyList_Check(dval)) {
1383                int number = PyList_Size(dval);
1384                if (TOPOLY(gelem)->number != number) {
1385                   TOPOLY(gelem)->points = (pointlist)realloc(
1386                         TOPOLY(gelem)->points, number * sizeof(XPoint));
1387                   TOPOLY(gelem)->number = number;
1388                }
1389                for (i = 0; i < number; i++) {
1390                   pval = PyList_GetItem(dval, i);
1391                   if (PyTuple_Check(pval) && PyTuple_Size(pval) == 2) {
1392                      qval = PyTuple_GetItem(pval, 0);
1393                      TOPOLY(gelem)->points[i].x = (short)PyInt_AsLong(qval);
1394                      qval = PyTuple_GetItem(pval, 1);
1395                      TOPOLY(gelem)->points[i].y = (short)PyInt_AsLong(qval);
1396                   }
1397                   else {
1398                      PyErr_SetString(PyExc_TypeError,
1399                                 "must have a tuple of 2 values per point");
1400                      break;
1401                   }
1402                }
1403             }
1404             else {
1405                PyErr_SetString(PyExc_TypeError,
1406                         "points must be in a list of tuples");
1407                break;
1408             }
1409          }
1410          break;
1411    }
1412
1413    calcbbox(areawin->topinstance);
1414    return PyInt_FromLong((long)(*gelem));
1415 }
1416 /*--------------------------------------------------------------*/
1417 /* Set various options through the "set" command.               */
1418 /* "set <option> on|off" supercedes "enable|disable <option>"   */
1419 /*--------------------------------------------------------------*/
1420
1421 static PyObject *xc_set(PyObject *self, PyObject *args)
1422 {
1423    const char *sarg1, *sarg2;
1424    int i;
1425    Boolean a = True;
1426    short cpage = areawin->page;
1427
1428    if (!PyArg_ParseTuple(args, "ss:set", &sarg1, &sarg2))
1429       return NULL;
1430
1431    if (!strcmp(sarg2, "On") || !strcmp(sarg2, "on") || !strcmp(sarg2, "True")
1432         || !strcmp(sarg2, "true"))
1433       a = False;     /* has to be backwards; toggle() inverts the value! */
1434
1435    if (!strcmp(sarg1, "font")) {
1436       for (i = 0; i < fontcount; i++)
1437          if (!strcmp(fonts[i].psname, sarg2)) break;
1438
1439       if (i == fontcount)
1440          loadfontfile((char *)sarg2);
1441
1442       /* loadfontfile() may load multiple fonts, so we have to check again */
1443       /* to see which one matches.                                         */
1444
1445       for (i = 0; i < fontcount; i++) {
1446          if (!strcmp(fonts[i].psname, sarg2)) {
1447             areawin->psfont = i;
1448             setdefaultfontmarks();
1449             break;
1450          }
1451       }
1452    }
1453    else if (!strcmp(sarg1, "fontscale")) {
1454       sscanf(sarg2, "%f", &areawin->textscale);
1455    }
1456    else if (!strcmp(sarg1, "axis") || !strcmp(sarg1, "axes")) {
1457       areawin->axeson = a;
1458       toggle(GridAxesButton, (pointertype)&areawin->axeson, NULL);
1459    }
1460    else if (!strcmp(sarg1, "grid")) {
1461       areawin->gridon = a;
1462       toggle(GridGridButton, (pointertype)&areawin->gridon, NULL);
1463    }
1464    else if (!strcmp(sarg1, "snap") || !strcmp(sarg1, "snap-to")) {
1465       areawin->snapto = a;
1466       toggle(SnaptoSnaptoButton, (pointertype)&areawin->snapto, NULL);
1467    }
1468    else if (!strcmp(sarg1, "gridspace")) {
1469       sscanf(sarg2, "%f", &xobjs.pagelist[cpage]->gridspace);
1470    }
1471    else if (!strcmp(sarg1, "snapspace")) {
1472       sscanf(sarg2, "%f", &xobjs.pagelist[cpage]->snapspace);
1473    }
1474    else if (!strcmp(sarg1, "pagestyle")) {
1475       if (!strcmp(sarg2, "encapsulated") || !strcmp(sarg2, "eps"))
1476          xobjs.pagelist[cpage]->pmode = 0;
1477       else
1478          xobjs.pagelist[cpage]->pmode = 1;
1479    }
1480    else if (!strcmp(sarg1, "boxedit")) {
1481       if (!strcmp(sarg2, "rhomboid-x")) boxedit(NULL, RHOMBOIDX, NULL);
1482       else if (!strcmp(sarg2, "rhomboid-y")) boxedit(NULL, RHOMBOIDY, NULL);
1483       else if (!strcmp(sarg2, "rhomboid-a")) boxedit(NULL, RHOMBOIDA, NULL);
1484       else if (!strcmp(sarg2, "manhattan")) boxedit(NULL, MANHATTAN, NULL);
1485       else if (!strcmp(sarg2, "normal")) boxedit(NULL, NORMAL, NULL);
1486    }
1487    else if (!strcmp(sarg1, "linewidth")) {
1488       sscanf(sarg2, "%f", &areawin->linewidth);
1489    }
1490    else if (!strcmp(sarg1, "colorscheme")) {
1491       if (!strcmp(sarg2, "inverse"))
1492          areawin->invert = False;
1493       inversecolor(NULL, (pointertype)&areawin->invert, NULL);
1494    }
1495    else if (!strcmp(sarg1, "coordstyle")) {
1496       if (!strcmp(sarg2, "cm") || !strcmp(sarg2, "centimeters")) {
1497          xobjs.pagelist[cpage]->coordstyle = CM;
1498          xobjs.pagelist[cpage]->pagesize.x = 595;  /* A4 size */
1499          xobjs.pagelist[cpage]->pagesize.y = 842;
1500          togglegrid((u_short)xobjs.pagelist[cpage]->coordstyle);
1501       }
1502    }
1503    else if (!strcmp(sarg1, "orient")) {   /* "orient" or "orientation" */
1504       if (!strcmp(sarg2, "landscape"))
1505          xobjs.pagelist[cpage]->orient = 90; /* Landscape */
1506       else
1507          xobjs.pagelist[cpage]->orient = 0;  /* Portrait */
1508    }
1509
1510    else if (!strcmp(sarg1, "xschema") || !strcmp(sarg1, "schema")) {
1511       /* Do nothing---retained for backward compatibility only */
1512    }
1513 #ifdef HAVE_XPM
1514    else if (!strcmp(sarg1, "toolbar")) {
1515       areawin->toolbar_on = a;
1516       dotoolbar(OptionsDisableToolbarButton, NULL, NULL);
1517     }
1518 #endif
1519
1520    return PyString_FromString(sarg2);
1521 }
1522
1523 /*--------------------------------------------------------------*/
1524
1525 static PyObject *xc_override(PyObject *self, PyObject *args)
1526 {
1527    const char *sarg1;
1528
1529    if (!PyArg_ParseTuple(args, "s:override", &sarg1))
1530       return NULL;
1531
1532    if (!strcmp(sarg1, "library") || !strcmp(sarg1, "libraries"))
1533       flags |= LIBOVERRIDE;
1534    else if (!strcmp(sarg1, "color") || !strcmp(sarg1, "colors"))
1535       flags |= COLOROVERRIDE;
1536    else if (!strcmp(sarg1, "font") || !strcmp(sarg1, "fonts"))
1537       flags |= FONTOVERRIDE;
1538    if (!strcmp(sarg1, "key") || !strcmp(sarg1, "keybindings"))
1539       flags |= KEYOVERRIDE;
1540
1541    return PyInt_FromLong(0L);
1542 }
1543
1544 /*--------------------------------------------------------------*/
1545
1546 static PyObject *xc_library(PyObject *self, PyObject *args)
1547 {
1548    const char *libname;
1549    int libnum = 1;
1550
1551    if (!PyArg_ParseTuple(args, "s|i:library", &libname, &libnum))
1552       return NULL;
1553
1554    /* if loading of default libraries is not overridden, load them first */
1555
1556    if (!(flags & (LIBOVERRIDE | LIBLOADED))) {
1557       defaultscript();
1558       flags |= LIBLOADED;   /* Pass through a Python variable? */
1559    }
1560
1561    if (libnum >= xobjs.numlibs || libnum < 0)
1562       libnum = createlibrary(FALSE);
1563    else
1564       libnum += LIBRARY - 1;
1565
1566    strcpy(_STR, libname);
1567    loadlibrary(libnum);
1568    return PyInt_FromLong((long)libnum);
1569 }
1570
1571 /*--------------------------------------------------------------*/
1572
1573 static PyObject *xc_font(PyObject *self, PyObject *args)
1574 {
1575    const char *fontname;
1576
1577    if (!PyArg_ParseTuple(args, "s:font", &fontname))
1578       return NULL;
1579
1580    if (!(flags & FONTOVERRIDE)) {
1581       loadfontfile("Helvetica");
1582       flags |= FONTOVERRIDE;
1583    }
1584    loadfontfile((char *)fontname);
1585    return PyString_FromString(fontname);
1586 }
1587
1588 /*--------------------------------------------------------------*/
1589
1590 static PyObject *xc_color(PyObject *self, PyObject *args)
1591 {
1592    PyObject *pcolor;
1593    int cidx;
1594
1595    if (!PyArg_ParseTuple(args, "O:color", &pcolor))
1596       return NULL;
1597
1598    cidx = PyRGBToIndex(pcolor);
1599    return PyIndexToRGB(cidx);
1600 }
1601
1602 /*--------------------------------------------------------------*/
1603
1604 static PyObject *xc_bind(PyObject *self, PyObject *args)
1605 {
1606    const char *keyname = NULL;
1607    const char *function = NULL;
1608    PyObject *retobj;
1609    int keywstate;
1610
1611    if (!PyArg_ParseTuple(args, "|ss:bind", &keyname, &function))
1612       return NULL;
1613
1614    /* If we're in .xcircuitrc and we're not overriding the key      */
1615    /* bindings, then the first binding function should precipitate  */
1616    /* calling the defaults, then specify the bindings as overridden */
1617    if (!(flags & KEYOVERRIDE)) {
1618       default_keybindings();
1619       flags |= KEYOVERRIDE;
1620    }
1621
1622    /* No arguments?  Return a dictionary of bound pairs */
1623    if (!keyname) {
1624       PyObject *key, *value;
1625       char *keyname, *funcname;
1626       keybinding *ksearch;
1627
1628       retobj = PyDict_New();
1629       for (ksearch = keylist; ksearch != NULL; ksearch = ksearch->nextbinding) {
1630          keyname = key_to_string(ksearch->keywstate);
1631          if (ksearch->value >= 0) {
1632             funcname = malloc(strlen(func_to_string(ksearch->function)) + 5);
1633             sprintf(funcname, "%s %d", func_to_string(ksearch->function),
1634                 ksearch->value);
1635          }
1636          else
1637             funcname = func_to_string(ksearch->function);
1638          key = PyString_FromString(keyname);
1639          value = PyString_FromString(funcname);
1640          PyDict_SetItem(retobj, key, value);
1641          free(keyname);
1642          if (ksearch->value >= 0) free(funcname);
1643       }
1644    }
1645    /* One argument?  Argument is a key or a function */
1646    else if (!function) {
1647       char *binding;
1648       int func = -1;
1649       keywstate = string_to_key(keyname);
1650       if (keywstate == 0) { /* first argument (keyname) is function? */
1651          keywstate = -1;
1652          func = string_to_func(keyname, NULL);
1653       }
1654       if (keywstate == -1)
1655          binding = function_binding_to_string(0, func);
1656       else
1657          binding = key_binding_to_string(0, keywstate);
1658       retobj = PyString_FromString(binding);
1659       free(binding);
1660    }
1661    else {
1662       if (add_keybinding(0, keyname, function) < 0) {
1663          /* Function may be a Python function, not a C function */
1664          keywstate = string_to_key(keyname);
1665          sprintf(_STR2, "keydict[%d] = %s\n", keywstate, function);
1666          PyRun_SimpleString(_STR2);
1667       }
1668       retobj = PyString_FromString(keyname);
1669    }
1670    return retobj;
1671 }
1672
1673 /*--------------------------------------------------------------*/
1674
1675 static PyObject *xc_unbind(PyObject *self, PyObject *args)
1676 {
1677    const char *keyname = NULL;
1678    const char *function = NULL;
1679
1680    if (!PyArg_ParseTuple(args, "ss:unbind", &keyname, &function))
1681       return NULL;
1682
1683    /* If we're in .xcircuitrc and we're not overriding the key      */
1684    /* bindings, then the first binding function should precipitate  */
1685    /* calling the defaults, then specify the bindings as overridden */
1686    if (!(flags & KEYOVERRIDE)) {
1687       default_keybindings();
1688       flags |= KEYOVERRIDE;
1689    }
1690
1691    remove_keybinding(areawin->area, keyname, function);
1692    return PyString_FromString(keyname);
1693 }
1694
1695 /*--------------------------------------------------------------*/
1696 /* active delay                                                 */
1697 /*--------------------------------------------------------------*/
1698
1699 static PyObject *xc_pause(PyObject *self, PyObject *args)
1700 {
1701    float delay;
1702
1703    if (!PyArg_ParseTuple(args, "f:pause", &delay))
1704       return NULL;
1705
1706    usleep((int)(1e6 * delay));
1707    return PyInt_FromLong((int)(1e6 * delay));
1708 }
1709
1710 /*--------------------------------------------------------------*/
1711 /* active refresh                                               */
1712 /*--------------------------------------------------------------*/
1713
1714 static PyObject *xc_refresh(PyObject *self, PyObject *args)
1715 {
1716    XEvent event;
1717
1718    if (!PyArg_ParseTuple(args, ":refresh"))
1719       return NULL;
1720
1721    refresh(NULL, NULL, NULL);
1722
1723    while (XCheckWindowEvent(dpy, areawin->window, ~NoEventMask, &event))
1724          XtDispatchEvent(&event);
1725
1726    return PyInt_FromLong(0L);
1727 }
1728
1729 /*--------------------------------------------------------------*/
1730 /* Callback procedure for Python-generated buttons              */
1731 /*--------------------------------------------------------------*/
1732
1733 int pybutton(Widget w, caddr_t clientdata, caddr_t calldata)
1734 {
1735    int status;
1736
1737    sprintf(_STR2, "buttondict[%ld]()\n", (long int)w);
1738    status = PyRun_SimpleString(_STR2);
1739    refresh(NULL, NULL, NULL);
1740    return status;
1741 }
1742
1743 /*--------------------------------------------------------------*/
1744 /* Add a new button to the specified (by name) cascade menu     */
1745 /*--------------------------------------------------------------*/
1746
1747 static PyObject *xc_newbutton(PyObject *self, PyObject *args)
1748 {
1749    const char *pname = NULL;
1750    const char *newbname = NULL;
1751    const char *pfunction = NULL;
1752    int status;
1753    Arg  wargs[1];
1754    int  i, n = 0;
1755    Widget newbutton, cascade, tbutton;
1756
1757    if (!PyArg_ParseTuple(args, "sss:newbutton", &pname, &newbname, &pfunction))
1758       return NULL;
1759
1760    for (i = 0; i < MaxMenuWidgets; i++) {
1761       tbutton = menuwidgets[i];
1762       cascade = XtParent(tbutton);
1763       if (!strcmp(XtName(cascade), pname)) break;
1764    }
1765    if (i == MaxMenuWidgets) {
1766       Wprintf("Cannot find specified menu.");
1767       return NULL;
1768    }
1769
1770    XtnSetArg(XtNfont, appdata.xcfont);
1771    newbutton = XtCreateWidget(newbname, XwmenubuttonWidgetClass,
1772          cascade, wargs, n);
1773
1774    XtAddCallback (newbutton, XtNselect, (XtCallbackProc)pybutton, newbutton);
1775    XtManageChild(newbutton);
1776
1777    sprintf(_STR2, "buttondict[%ld] = %s\n", (long int)newbutton, pfunction);
1778    status = PyRun_SimpleString(_STR2);
1779    return PyInt_FromLong((long)status);
1780 }
1781
1782 #ifdef HAVE_XPM
1783
1784 /*--------------------------------------------------------------*/
1785 /* Callback procedure for Python-generated toolbar tool         */
1786 /*--------------------------------------------------------------*/
1787
1788 int pytool(Widget w, caddr_t clientdata, caddr_t calldata)
1789 {
1790    int status;
1791
1792    sprintf(_STR2, "tooldict[%ld]()\n", (long int)w);
1793    status = PyRun_SimpleString(_STR2);
1794    refresh(NULL, NULL, NULL);
1795    return status;
1796 }
1797
1798 /*--------------------------------------------------------------*/
1799 /* Add a new tool to the toolbar                                */
1800 /*--------------------------------------------------------------*/
1801
1802 static PyObject *xc_newtool(PyObject *self, PyObject *args)
1803 {
1804    const char *thint = NULL;
1805    const char *pixfile = NULL;
1806    const char *newtname = NULL;
1807    const char *pfunction = NULL;
1808    int status;
1809    Arg  wargs[8];
1810    int  i, n = 0;
1811    Widget newtool, cascade, tbutton;
1812    XImage *iret;
1813    XpmAttributes attr;
1814
1815    attr.valuemask = XpmSize | XpmCloseness;
1816    attr.closeness = 65536;
1817
1818    if (!PyArg_ParseTuple(args, "sss|s:newtool", &newtname, &pfunction, &pixfile,
1819                 &thint))
1820       return NULL;
1821
1822    if (XpmReadFileToImage(dpy, (char *)pixfile, &iret, NULL, &attr) < 0) {
1823       Wprintf("Cannot find or open pixmap file \'%s\'", pixfile);
1824       XpmCreateImageFromData(dpy, q_xpm, &iret, NULL, &attr);
1825    }
1826
1827    XtnSetArg(XtNlabelType, XwIMAGE);
1828    XtnSetArg(XtNlabelImage, iret);
1829    XtnSetArg(XtNwidth, attr.width + 4);
1830    XtnSetArg(XtNheight, attr.height + 4);
1831    XtnSetArg(XtNborderWidth, TBBORDER);
1832    XtnSetArg(XtNnoPad, True);
1833    if (thint != NULL) {
1834       XtnSetArg(XtNhint, thint);
1835       XtnSetArg(XtNhintProc, Wprintf);
1836    }
1837    newtool = XtCreateWidget(newtname, XwmenubuttonWidgetClass, toolbar, wargs, n);
1838
1839    XtAddCallback (newtool, XtNselect, (XtCallbackProc)pybutton, newtool);
1840    XtManageChild(newtool);
1841
1842    sprintf(_STR2, "tooldict[%ld] = %s\n", (long int)newtool, pfunction);
1843    status = PyRun_SimpleString(_STR2);
1844    return PyInt_FromLong((long)status);
1845 }
1846
1847 /*------------------------------------------------------------------*/
1848 /* Return a list of the widgets in tooldict                         */
1849 /* (memory for list is allocated here and must be free'd elsewhere) */
1850 /*------------------------------------------------------------------*/
1851
1852 Widget *pytoolbuttons(int *num_tools)
1853 {
1854    Widget *ptools;
1855    PyObject *rval;
1856    int i;
1857
1858    if (xcmod == NULL) {
1859       *num_tools = 0;
1860       return NULL;
1861    }
1862    rval = PyRun_ObjString("len(tooldict)");
1863    if (!rval) {
1864       PyErr_Clear();
1865       return NULL;
1866    }
1867    *num_tools = (int)PyInt_AsLong(rval);
1868    Py_DECREF(rval);
1869    /* fprintf(stderr, "num_tools = %d\n", *num_tools); */
1870
1871    if (*num_tools <= 0) return NULL;
1872
1873    ptools = (Widget *)malloc(*num_tools * sizeof(Widget));
1874
1875    for (i = 0; i < *num_tools; i++) {
1876       sprintf(_STR2, "tooldict[%d]", i);
1877       rval = PyRun_ObjString(_STR2);
1878       if (!rval) {
1879          PyErr_Clear();
1880          return NULL;
1881       }
1882       ptools[i] = (Widget)PyInt_AsLong(rval);
1883       Py_DECREF(rval);
1884    }
1885    return ptools;
1886 }
1887
1888 #endif
1889
1890 /*----------------------------------------------------------------*/
1891 /* Execute a python command from the key-function pair dictionary */
1892 /*----------------------------------------------------------------*/
1893
1894 int python_key_command(int keystate)
1895 {
1896    PyObject *rval;
1897    int status;
1898    sprintf(_STR2, "keydict[%d]\n", keystate);
1899    rval = PyRun_ObjString(_STR2);
1900    if (!rval) {
1901       PyErr_Clear();
1902       return -1;
1903    }
1904    Py_DECREF(rval);
1905
1906    sprintf(_STR2, "keydict[%d]()\n", keystate);
1907    PyRun_SimpleString(_STR2);
1908    refresh(NULL, NULL, NULL);
1909    return 0;
1910 }
1911
1912 /*--------------------------------------------------------------*/
1913 /* Declaration of the xcircuit Python functions                 */
1914 /*--------------------------------------------------------------*/
1915
1916 static PyMethodDef xc_methods[] = {
1917    {"set",              xc_set,         1},
1918    {"override",         xc_override,    1},
1919    {"library",          xc_library,     1},
1920    {"font",             xc_font,        1},
1921    {"color",            xc_color,       1},
1922    {"newelement",       xc_new,         1},
1923    {"getpage",          xc_getpage,     1},
1924    {"getlibrary",       xc_getlibrary,  1},
1925    {"getobject",        xc_getobject,   1},
1926    {"getattr",          xc_getattr,     1},
1927    {"setattr",          xc_setattr,     1},
1928    {"refresh",          xc_refresh,     1},
1929    {"pause",            xc_pause,       1},
1930    {"bind",             xc_bind,        1},
1931    {"unbind",           xc_unbind,      1},
1932    {"getcursor",        xc_getcursor,   1},
1933    {"getwindow",        xc_getwindow,   1},
1934    {"zoom",             xc_zoom,        1},
1935    {"pan",              xc_pan,         1},
1936    {"popupprompt",      xc_popupprompt, 1},
1937    {"filepopup",        xc_filepopup,   1},
1938    {"simplepopup",      xc_simplepopup, 1},
1939    {"newbutton",        xc_newbutton,   1},
1940    {"reset",            xc_reset,       1},
1941    {"page",             xc_page,        1},
1942    {"load",             xc_load,        1},
1943 #ifdef HAVE_XPM
1944    {"newtool",          xc_newtool,     1},
1945 #endif
1946    {"netlist",          xc_netlist,     1},
1947    {NULL,       NULL}                   /* sentinel */
1948 };
1949
1950 /*--------------------------------------------------------------*/
1951 /* Initialize Python interpreter and load all xcircuit methods  */
1952 /*--------------------------------------------------------------*/
1953 void init_interpreter()
1954 {
1955    Py_SetProgramName("XCircuit");
1956    Py_Initialize();
1957    PyImport_AddModule("xc");
1958    xcmod = Py_InitModule("xc", xc_methods);
1959    PyRun_SimpleString("from xc import *\n");
1960    PyRun_SimpleString("keydict = {}\n");        /* initialize key/function pairs */
1961    PyRun_SimpleString("buttondict = {}\n");  /* initialize button/function pairs */
1962    PyRun_SimpleString("tooldict = {}\n");  /* initialize tool/function pairs */
1963    sprintf(_STR, "xc_version = %s\n", PROG_VERSION);
1964    PyRun_SimpleString(_STR);
1965 }
1966
1967 /*--------------------------------------------------------------*/
1968 /* Exit the Python interpreter                                  */
1969 /*--------------------------------------------------------------*/
1970
1971 void exit_interpreter()
1972 {
1973    Py_Exit(0);
1974 }
1975
1976 /*--------------------------------------------------------------*/
1977 /* Replace the functions of the simple rcfile.c interpreter.    */
1978 /*--------------------------------------------------------------*/
1979
1980 /*----------------------------------------------------------------------*/
1981 /* Execute a single command from a script or from the command line      */
1982 /*----------------------------------------------------------------------*/
1983
1984 short execcommand(short pflags, char *cmdptr)
1985 {
1986    flags = pflags;
1987    PyRun_SimpleString(cmdptr);
1988    refresh(NULL, NULL, NULL);
1989    return flags;
1990 }
1991
1992 /*----------------------------------------------------------------------*/
1993 /* Load the default script (like execscript() but don't allow recursive */
1994 /* loading of the startup script)                                       */
1995 /*----------------------------------------------------------------------*/
1996
1997 void defaultscript()
1998 {
1999    FILE *fd;
2000    char *tmp_s = getenv((const char *)"XCIRCUIT_SRC_DIR");
2001
2002    flags = LIBOVERRIDE | LIBLOADED | FONTOVERRIDE;
2003
2004    if (!tmp_s) tmp_s = SCRIPTS_DIR;
2005    sprintf(_STR2, "%s/%s", tmp_s, STARTUP_FILE);
2006
2007    if ((fd = fopen(_STR2, "r")) == NULL) {
2008       sprintf(_STR2, "%s/%s", SCRIPTS_DIR, STARTUP_FILE);
2009       if ((fd = fopen(_STR2, "r")) == NULL) {
2010          Wprintf("Failed to open startup script \"%s\"\n", STARTUP_FILE);
2011          return;
2012       }
2013    }
2014    PyRun_SimpleFile(fd, _STR2);
2015 }
2016
2017 /*----------------------------------------------------------------------*/
2018 /* Execute a script                                                     */
2019 /*----------------------------------------------------------------------*/
2020
2021 void execscript()
2022 {
2023    FILE *fd;
2024
2025    flags = 0;
2026
2027    xc_tilde_expand(_STR2, 249);
2028    if ((fd = fopen(_STR2, "r")) != NULL) {
2029       PyRun_SimpleFile(fd, _STR2);
2030       refresh(NULL, NULL, NULL);
2031    }
2032    else {
2033       Wprintf("Failed to open script file \"%s\"\n", _STR2);
2034    }
2035 }
2036
2037 /*----------------------------------------------------------------------*/
2038 /* Execute the .xcircuitrc startup script                               */
2039 /*----------------------------------------------------------------------*/
2040
2041 void loadrcfile()
2042 {
2043    char *userdir = getenv((const char *)"HOME");
2044    FILE *fd;
2045    short i;
2046
2047    /* Initialize flags */
2048
2049    flags = 0;
2050
2051    sprintf(_STR2, "%s", USER_RC_FILE);     /* Name imported from Makefile */
2052
2053    /* try first in current directory, then look in user's home directory */
2054
2055    xc_tilde_expand(_STR2, 249);
2056    if ((fd = fopen(_STR2, "r")) == NULL) {
2057       if (userdir != NULL) {
2058          sprintf(_STR2, "%s/%s", userdir, USER_RC_FILE);
2059          fd = fopen(_STR2, "r");
2060       }
2061    }
2062    if (fd != NULL)
2063       PyRun_SimpleFile(fd, _STR2);
2064
2065    /* Add the default font if not loaded already */
2066
2067    if (!(flags & FONTOVERRIDE)) {
2068       loadfontfile("Helvetica");
2069       if (areawin->psfont == -1)
2070          for (i = 0; i < fontcount; i++)
2071             if (!strcmp(fonts[i].psname, "Helvetica")) {
2072                areawin->psfont = i;
2073                break;
2074             }
2075    }
2076
2077    if (areawin->psfont == -1) areawin->psfont = 0;
2078
2079    setdefaultfontmarks();
2080
2081    /* arrange the loaded libraries */
2082
2083    if (!(flags & (LIBOVERRIDE | LIBLOADED)))
2084       defaultscript();
2085
2086    /* Add the default colors */
2087
2088    if (!(flags & COLOROVERRIDE)) {
2089       addnewcolorentry(xc_alloccolor("Gray40"));
2090       addnewcolorentry(xc_alloccolor("Gray60"));
2091       addnewcolorentry(xc_alloccolor("Gray80"));
2092       addnewcolorentry(xc_alloccolor("Gray90"));
2093       addnewcolorentry(xc_alloccolor("Red"));
2094       addnewcolorentry(xc_alloccolor("Blue"));
2095       addnewcolorentry(xc_alloccolor("Green2"));
2096       addnewcolorentry(xc_alloccolor("Yellow"));
2097       addnewcolorentry(xc_alloccolor("Purple"));
2098       addnewcolorentry(xc_alloccolor("SteelBlue2"));
2099       addnewcolorentry(xc_alloccolor("Red3"));
2100       addnewcolorentry(xc_alloccolor("Tan"));
2101       addnewcolorentry(xc_alloccolor("Brown"));
2102    }
2103
2104    /* These colors must be enabled whether or not colors are overridden, */
2105    /* because they are needed by the schematic capture system.           */
2106
2107    addnewcolorentry(xc_getlayoutcolor(LOCALPINCOLOR));
2108    addnewcolorentry(xc_getlayoutcolor(GLOBALPINCOLOR));
2109    addnewcolorentry(xc_getlayoutcolor(INFOLABELCOLOR));
2110    addnewcolorentry(xc_getlayoutcolor(RATSNESTCOLOR));
2111    addnewcolorentry(xc_getlayoutcolor(BBOXCOLOR));
2112
2113    if (!(flags & KEYOVERRIDE))
2114       default_keybindings();
2115 }
2116
2117 #endif
2118 /* #endif HAVE_PYTHON and !TCL_WRAPPER */
2119 /*--------------------------------------------------------------*/