Modules/cstubs

   1 /***********************************************************
   2 Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
   3 The Netherlands.
   4
   5                         All Rights Reserved
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the names of Stichting Mathematisch
  12 Centrum or CWI or Corporation for National Research Initiatives or
  13 CNRI not be used in advertising or publicity pertaining to
  14 distribution of the software without specific, written prior
  15 permission.
  16
  17 While CWI is the initial source for this software, a modified version
  18 is made available by the Corporation for National Research Initiatives
  19 (CNRI) at the Internet address ftp://ftp.python.org.
  20
  21 STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22 REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23 MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24 CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26 PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27 TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28 PERFORMANCE OF THIS SOFTWARE.
  29
  30 ******************************************************************/
  31
  32 /*
  33 Input used to generate the Python module "glmodule.c".
  34 The stub generator is a Python script called "cgen.py".
  35
  36 Each definition must be contained on one line:
  37
  38 <returntype> <name> <type> <arg> <type> <arg>
  39
  40 <returntype> can be: void, short, long (XXX maybe others?)
  41
  42 <type> can be: char, string, short, float, long, or double
  43         string indicates a null terminated string;
  44         if <type> is char and <arg> begins with a *, the * is stripped
  45         and <type> is changed into string
  46
  47 <arg> has the form <mode> or <mode>[<subscript>]
  48         where <mode> can be
  49                 s: arg is sent
  50                 r: arg is received              (arg is a pointer)
  51         and <subscript> can be (N and I are numbers):
  52                 N
  53                 argI
  54                 retval
  55                 N*argI
  56                 N*I
  57                 N*retval
  58         In the case where the subscript consists of two parts
  59         separated by *, the first part is the width of the matrix, and
  60         the second part is the length of the matrix.  This order is
  61         opposite from the order used in C to declare a two-dimensional
  62         matrix.
  63 */
  64
  65 /*
  66  * An attempt has been made to make this module switch threads on qread
  67  * calls. It is far from safe, though.
  68  */
  69
  70 #include <gl.h>
  71 #include <device.h>
  72
  73 #ifdef __sgi
  74 extern int devport();
  75 extern int textwritemask();
  76 extern int pagewritemask();
  77 extern int gewrite();
  78 extern int gettp();
  79 #endif
  80
  81 #include "Python.h"
  82 #include "cgensupport.h"
  83
  84 /*
  85 Some stubs are too complicated for the stub generator.
  86 We can include manually written versions of them here.
  87 A line starting with '%' gives the name of the function so the stub
  88 generator can include it in the table of functions.
  89 */
  90
  91 % qread
  92
  93 static PyObject *
  94 gl_qread(self, args)
  95         PyObject *self;
  96         PyObject *args;
  97 {
  98         long retval;
  99         short arg1 ;
 100         Py_BEGIN_ALLOW_THREADS
 101         retval = qread( & arg1 );
 102         Py_END_ALLOW_THREADS
 103         { PyObject *v = PyTuple_New( 2 );
 104           if (v == NULL) return NULL;
 105           PyTuple_SetItem(v, 0, mknewlongobject(retval));
 106           PyTuple_SetItem(v, 1, mknewshortobject(arg1));
 107           return v;
 108         }
 109 }
 110
 111
 112 /*
 113 varray -- an array of v.. calls.
 114 The argument is an array (maybe list or tuple) of points.
 115 Each point must be a tuple or list of coordinates (x, y, z).
 116 The points may be 2- or 3-dimensional but must all have the
 117 same dimension.  Float and int values may be mixed however.
 118 The points are always converted to 3D double precision points
 119 by assuming z=0.0 if necessary (as indicated in the man page),
 120 and for each point v3d() is called.
 121 */
 122
 123 % varray
 124
 125 static PyObject *
 126 gl_varray(self, args)
 127         PyObject *self;
 128         PyObject *args;
 129 {
 130         PyObject *v, *w=NULL;
 131         int i, n, width;
 132         double vec[3];
 133         PyObject * (*getitem) Py_FPROTO((PyObject *, int));
 134
 135         if (!PyArg_GetObject(args, 1, 0, &v))
 136                 return NULL;
 137
 138         if (PyList_Check(v)) {
 139                 n = PyList_Size(v);
 140                 getitem = PyList_GetItem;
 141         }
 142         else if (PyTuple_Check(v)) {
 143                 n = PyTuple_Size(v);
 144                 getitem = PyTuple_GetItem;
 145         }
 146         else {
 147                 PyErr_BadArgument();
 148                 return NULL;
 149         }
 150
 151         if (n == 0) {
 152                 Py_INCREF(Py_None);
 153                 return Py_None;
 154         }
 155         if (n > 0)
 156                 w = (*getitem)(v, 0);
 157
 158         width = 0;
 159         if (w == NULL) {
 160         }
 161         else if (PyList_Check(w)) {
 162                 width = PyList_Size(w);
 163         }
 164         else if (PyTuple_Check(w)) {
 165                 width = PyTuple_Size(w);
 166         }
 167
 168         switch (width) {
 169         case 2:
 170                 vec[2] = 0.0;
 171                 /* Fall through */
 172         case 3:
 173                 break;
 174         default:
 175                 PyErr_BadArgument();
 176                 return NULL;
 177         }
 178
 179         for (i = 0; i < n; i++) {
 180                 w = (*getitem)(v, i);
 181                 if (!PyArg_GetDoubleArray(w, 1, 0, width, vec))
 182                         return NULL;
 183                 v3d(vec);
 184         }
 185
 186         Py_INCREF(Py_None);
 187         return Py_None;
 188 }
 189
 190 /*
 191 vnarray, nvarray -- an array of n3f and v3f calls.
 192 The argument is an array (list or tuple) of pairs of points and normals.
 193 Each pair is a tuple (NOT a list) of a point and a normal for that point.
 194 Each point or normal must be a tuple (NOT a list) of coordinates (x, y, z).
 195 Three coordinates must be given.  Float and int values may be mixed.
 196 For each pair, n3f() is called for the normal, and then v3f() is called
 197 for the vector.
 198
 199 vnarray and nvarray differ only in the order of the vector and normal in
 200 the pair: vnarray expects (v, n) while nvarray expects (n, v).
 201 */
 202
 203 static PyObject *gen_nvarray(); /* Forward */
 204
 205 % nvarray
 206
 207 static PyObject *
 208 gl_nvarray(self, args)
 209         PyObject *self;
 210         PyObject *args;
 211 {
 212         return gen_nvarray(args, 0);
 213 }
 214
 215 % vnarray
 216
 217 static PyObject *
 218 gl_vnarray(self, args)
 219         PyObject *self;
 220         PyObject *args;
 221 {
 222         return gen_nvarray(args, 1);
 223 }
 224
 225 /* Generic, internal version of {nv,nv}array: inorm indicates the
 226    argument order, 0: normal first, 1: vector first. */
 227
 228 static PyObject *
 229 gen_nvarray(args, inorm)
 230         PyObject *args;
 231         int inorm;
 232 {
 233         PyObject *v, *w, *wnorm, *wvec;
 234         int i, n;
 235         float norm[3], vec[3];
 236         PyObject * (*getitem) Py_FPROTO((PyObject *, int));
 237
 238         if (!PyArg_GetObject(args, 1, 0, &v))
 239                 return NULL;
 240
 241         if (PyList_Check(v)) {
 242                 n = PyList_Size(v);
 243                 getitem = PyList_GetItem;
 244         }
 245         else if (PyTuple_Check(v)) {
 246                 n = PyTuple_Size(v);
 247                 getitem = PyTuple_GetItem;
 248         }
 249         else {
 250                 PyErr_BadArgument();
 251                 return NULL;
 252         }
 253
 254         for (i = 0; i < n; i++) {
 255                 w = (*getitem)(v, i);
 256                 if (!PyTuple_Check(w) || PyTuple_Size(w) != 2) {
 257                         PyErr_BadArgument();
 258                         return NULL;
 259                 }
 260                 wnorm = PyTuple_GetItem(w, inorm);
 261                 wvec = PyTuple_GetItem(w, 1 - inorm);
 262                 if (!PyArg_GetFloatArray(wnorm, 1, 0, 3, norm) ||
 263                         !PyArg_GetFloatArray(wvec, 1, 0, 3, vec))
 264                         return NULL;
 265                 n3f(norm);
 266                 v3f(vec);
 267         }
 268
 269         Py_INCREF(Py_None);
 270         return Py_None;
 271 }
 272
 273 /* nurbssurface(s_knots[], t_knots[], ctl[][], s_order, t_order, type).
 274    The dimensions of ctl[] are computed as follows:
 275    [len(s_knots) - s_order], [len(t_knots) - t_order]
 276 */
 277
 278 % nurbssurface
 279
 280 static PyObject *
 281 gl_nurbssurface(self, args)
 282         PyObject *self;
 283         PyObject *args;
 284 {
 285         long arg1 ;
 286         double * arg2 ;
 287         long arg3 ;
 288         double * arg4 ;
 289         double *arg5 ;
 290         long arg6 ;
 291         long arg7 ;
 292         long arg8 ;
 293         long ncoords;
 294         long s_byte_stride, t_byte_stride;
 295         long s_nctl, t_nctl;
 296         long s, t;
 297         PyObject *v, *w, *pt;
 298         double *pnext;
 299         if (!PyArg_GetLongArraySize(args, 6, 0, &arg1))
 300                 return NULL;
 301         if ((arg2 = PyMem_NEW(double, arg1 )) == NULL) {
 302                 return PyErr_NoMemory();
 303         }
 304         if (!PyArg_GetDoubleArray(args, 6, 0, arg1 , arg2))
 305                 return NULL;
 306         if (!PyArg_GetLongArraySize(args, 6, 1, &arg3))
 307                 return NULL;
 308         if ((arg4 = PyMem_NEW(double, arg3 )) == NULL) {
 309                 return PyErr_NoMemory();
 310         }
 311         if (!PyArg_GetDoubleArray(args, 6, 1, arg3 , arg4))
 312                 return NULL;
 313         if (!PyArg_GetLong(args, 6, 3, &arg6))
 314                 return NULL;
 315         if (!PyArg_GetLong(args, 6, 4, &arg7))
 316                 return NULL;
 317         if (!PyArg_GetLong(args, 6, 5, &arg8))
 318                 return NULL;
 319         if (arg8 == N_XYZ)
 320                 ncoords = 3;
 321         else if (arg8 == N_XYZW)
 322                 ncoords = 4;
 323         else {
 324                 PyErr_BadArgument();
 325                 return NULL;
 326         }
 327         s_nctl = arg1 - arg6;
 328         t_nctl = arg3 - arg7;
 329         if (!PyArg_GetObject(args, 6, 2, &v))
 330                 return NULL;
 331         if (!PyList_Check(v) || PyList_Size(v) != s_nctl) {
 332                 PyErr_BadArgument();
 333                 return NULL;
 334         }
 335         if ((arg5 = PyMem_NEW(double, s_nctl*t_nctl*ncoords )) == NULL) {
 336                 return PyErr_NoMemory();
 337         }
 338         pnext = arg5;
 339         for (s = 0; s < s_nctl; s++) {
 340                 w = PyList_GetItem(v, s);
 341                 if (w == NULL || !PyList_Check(w) ||
 342                                         PyList_Size(w) != t_nctl) {
 343                         PyErr_BadArgument();
 344                         return NULL;
 345                 }
 346                 for (t = 0; t < t_nctl; t++) {
 347                         pt = PyList_GetItem(w, t);
 348                         if (!PyArg_GetDoubleArray(pt, 1, 0, ncoords, pnext))
 349                                 return NULL;
 350                         pnext += ncoords;
 351                 }
 352         }
 353         s_byte_stride = sizeof(double) * ncoords;
 354         t_byte_stride = s_byte_stride * s_nctl;
 355         nurbssurface( arg1 , arg2 , arg3 , arg4 ,
 356                 s_byte_stride , t_byte_stride , arg5 , arg6 , arg7 , arg8 );
 357         PyMem_DEL(arg2);
 358         PyMem_DEL(arg4);
 359         PyMem_DEL(arg5);
 360         Py_INCREF(Py_None);
 361         return Py_None;
 362 }
 363
 364 /* nurbscurve(knots, ctlpoints, order, type).
 365    The length of ctlpoints is len(knots)-order. */
 366
 367 %nurbscurve
 368
 369 static PyObject *
 370 gl_nurbscurve(self, args)
 371         PyObject *self;
 372         PyObject *args;
 373 {
 374         long arg1 ;
 375         double * arg2 ;
 376         long arg3 ;
 377         double * arg4 ;
 378         long arg5 ;
 379         long arg6 ;
 380         int ncoords, npoints;
 381         int i;
 382         PyObject *v;
 383         double *pnext;
 384         if (!PyArg_GetLongArraySize(args, 4, 0, &arg1))
 385                 return NULL;
 386         if ((arg2 = PyMem_NEW(double, arg1 )) == NULL) {
 387                 return PyErr_NoMemory();
 388         }
 389         if (!PyArg_GetDoubleArray(args, 4, 0, arg1 , arg2))
 390                 return NULL;
 391         if (!PyArg_GetLong(args, 4, 2, &arg5))
 392                 return NULL;
 393         if (!PyArg_GetLong(args, 4, 3, &arg6))
 394                 return NULL;
 395         if (arg6 == N_ST)
 396                 ncoords = 2;
 397         else if (arg6 == N_STW)
 398                 ncoords = 3;
 399         else {
 400                 PyErr_BadArgument();
 401                 return NULL;
 402         }
 403         npoints = arg1 - arg5;
 404         if (!PyArg_GetObject(args, 4, 1, &v))
 405                 return NULL;
 406         if (!PyList_Check(v) || PyList_Size(v) != npoints) {
 407                 PyErr_BadArgument();
 408                 return NULL;
 409         }
 410         if ((arg4 = PyMem_NEW(double, npoints*ncoords )) == NULL) {
 411                 return PyErr_NoMemory();
 412         }
 413         pnext = arg4;
 414         for (i = 0; i < npoints; i++) {
 415                 if (!PyArg_GetDoubleArray(PyList_GetItem(v, i), 1, 0, ncoords, pnext))
 416                         return NULL;
 417                 pnext += ncoords;
 418         }
 419         arg3 = (sizeof(double)) * ncoords;
 420         nurbscurve( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
 421         PyMem_DEL(arg2);
 422         PyMem_DEL(arg4);
 423         Py_INCREF(Py_None);
 424         return Py_None;
 425 }
 426
 427 /* pwlcurve(points, type).
 428    Points is a list of points. Type must be N_ST. */
 429
 430 %pwlcurve
 431
 432 static PyObject *
 433 gl_pwlcurve(self, args)
 434         PyObject *self;
 435         PyObject *args;
 436 {
 437         PyObject *v;
 438         long type;
 439         double *data, *pnext;
 440         long npoints, ncoords;
 441         int i;
 442         if (!PyArg_GetObject(args, 2, 0, &v))
 443                 return NULL;
 444         if (!PyArg_GetLong(args, 2, 1, &type))
 445                 return NULL;
 446         if (!PyList_Check(v)) {
 447                 PyErr_BadArgument();
 448                 return NULL;
 449         }
 450         npoints = PyList_Size(v);
 451         if (type == N_ST)
 452                 ncoords = 2;
 453         else {
 454                 PyErr_BadArgument();
 455                 return NULL;
 456         }
 457         if ((data = PyMem_NEW(double, npoints*ncoords)) == NULL) {
 458                 return PyErr_NoMemory();
 459         }
 460         pnext = data;
 461         for (i = 0; i < npoints; i++) {
 462                 if (!PyArg_GetDoubleArray(PyList_GetItem(v, i), 1, 0, ncoords, pnext))
 463                         return NULL;
 464                 pnext += ncoords;
 465         }
 466         pwlcurve(npoints, data, sizeof(double)*ncoords, type);
 467         PyMem_DEL(data);
 468         Py_INCREF(Py_None);
 469         return Py_None;
 470 }
 471
 472
 473 /* Picking and Selecting */
 474
 475 static short *pickbuffer = NULL;
 476 static long pickbuffersize;
 477
 478 static PyObject *
 479 pick_select(args, func)
 480         PyObject *args;
 481         void (*func)();
 482 {
 483         if (!PyArg_GetLong(args, 1, 0, &pickbuffersize))
 484                 return NULL;
 485         if (pickbuffer != NULL) {
 486                 PyErr_SetString(PyExc_RuntimeError,
 487                         "pick/gselect: already picking/selecting");
 488                 return NULL;
 489         }
 490         if ((pickbuffer = PyMem_NEW(short, pickbuffersize)) == NULL) {
 491                 return PyErr_NoMemory();
 492         }
 493         (*func)(pickbuffer, pickbuffersize);
 494         Py_INCREF(Py_None);
 495         return Py_None;
 496 }
 497
 498 static PyObject *
 499 endpick_select(args, func)
 500         PyObject *args;
 501         long (*func)();
 502 {
 503         PyObject *v, *w;
 504         int i, nhits, n;
 505         if (!PyArg_NoArgs(args))
 506                 return NULL;
 507         if (pickbuffer == NULL) {
 508                 PyErr_SetString(PyExc_RuntimeError,
 509                         "endpick/endselect: not in pick/select mode");
 510                 return NULL;
 511         }
 512         nhits = (*func)(pickbuffer);
 513         if (nhits < 0) {
 514                 nhits = -nhits; /* How to report buffer overflow otherwise? */
 515         }
 516         /* Scan the buffer to see how many integers */
 517         n = 0;
 518         for (; nhits > 0; nhits--) {
 519                 n += 1 + pickbuffer[n];
 520         }
 521         v = PyList_New(n);
 522         if (v == NULL)
 523                 return NULL;
 524         /* XXX Could do it nicer and interpret the data structure here,
 525            returning a list of lists. But this can be done in Python... */
 526         for (i = 0; i < n; i++) {
 527                 w = PyInt_FromLong((long)pickbuffer[i]);
 528                 if (w == NULL) {
 529                         Py_DECREF(v);
 530                         return NULL;
 531                 }
 532                 PyList_SetItem(v, i, w);
 533         }
 534         PyMem_DEL(pickbuffer);
 535         pickbuffer = NULL;
 536         return v;
 537 }
 538
 539 extern void pick(), gselect();
 540 extern long endpick(), endselect();
 541
 542 %pick
 543 static PyObject *gl_pick(self, args) PyObject *self, *args; {
 544         return pick_select(args, pick);
 545 }
 546
 547 %endpick
 548 static PyObject *gl_endpick(self, args) PyObject *self, *args; {
 549         return endpick_select(args, endpick);
 550 }
 551
 552 %gselect
 553 static PyObject *gl_gselect(self, args) PyObject *self, *args; {
 554         return pick_select(args, gselect);
 555 }
 556
 557 %endselect
 558 static PyObject *gl_endselect(self, args) PyObject *self, *args; {
 559         return endpick_select(args, endselect);
 560 }
 561
 562
 563 /* XXX The generator botches this one.  Here's a quick hack to fix it. */
 564
 565 /* XXX The generator botches this one.  Here's a quick hack to fix it. */
 566
 567 % getmatrix float r[16]
 568
 569 static PyObject *
 570 gl_getmatrix(self, args)
 571         PyObject *self;
 572         PyObject *args;
 573 {
 574         Matrix arg1;
 575         PyObject *v, *w;
 576         int i, j;
 577         getmatrix( arg1 );
 578         v = PyList_New(16);
 579         if (v == NULL) {
 580                 return PyErr_NoMemory();
 581         }
 582         for (i = 0; i < 4; i++) for (j = 0; j < 4; j++) {
 583                 w = mknewfloatobject(arg1[i][j]);
 584                 if (w == NULL) {
 585                         Py_DECREF(v);
 586                         return NULL;
 587                 }
 588                 PyList_SetItem(v, i*4+j, w);
 589         }
 590         return v;
 591 }
 592
 593 /* Here's an alternate version that returns a 4x4 matrix instead of
 594    a vector.  Unfortunately it is incompatible with loadmatrix and
 595    multmatrix... */
 596
 597 % altgetmatrix float r[4][4]
 598
 599 static PyObject *
 600 gl_altgetmatrix(self, args)
 601         PyObject *self;
 602         PyObject *args;
 603 {
 604         Matrix arg1;
 605         PyObject *v, *w;
 606         int i, j;
 607         getmatrix( arg1 );
 608         v = PyList_New(4);
 609         if (v == NULL) {
 610                 return NULL;
 611         }
 612         for (i = 0; i < 4; i++) {
 613                 w = PyList_New(4);
 614                 if (w == NULL) {
 615                         Py_DECREF(v);
 616                         return NULL;
 617                 }
 618                 PyList_SetItem(v, i, w);
 619         }
 620         for (i = 0; i < 4; i++) {
 621                 for (j = 0; j < 4; j++) {
 622                         w = mknewfloatobject(arg1[i][j]);
 623                         if (w == NULL) {
 624                                 Py_DECREF(v);
 625                                 return NULL;
 626                         }
 627                         PyList_SetItem(PyList_GetItem(v, i), j, w);
 628                 }
 629         }
 630         return v;
 631 }
 632
 633 % lrectwrite
 634
 635 static PyObject *
 636 gl_lrectwrite(self, args)
 637         PyObject *self;
 638         PyObject *args;
 639 {
 640         short x1 ;
 641         short y1 ;
 642         short x2 ;
 643         short y2 ;
 644         string parray ;
 645         PyObject *s;
 646 #if 0
 647         int pixcount;
 648 #endif
 649         if (!PyArg_GetShort(args, 5, 0, &x1))
 650                 return NULL;
 651         if (!PyArg_GetShort(args, 5, 1, &y1))
 652                 return NULL;
 653         if (!PyArg_GetShort(args, 5, 2, &x2))
 654                 return NULL;
 655         if (!PyArg_GetShort(args, 5, 3, &y2))
 656                 return NULL;
 657         if (!PyArg_GetString(args, 5, 4, &parray))
 658                 return NULL;
 659         if (!PyArg_GetObject(args, 5, 4, &s))
 660                 return NULL;
 661 #if 0
 662 /* Don't check this, it breaks experiments with pixmode(PM_SIZE, ...) */
 663         pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);
 664         if (!PyString_Check(s) || PyString_Size(s) != pixcount*sizeof(long)) {
 665                 PyErr_SetString(PyExc_RuntimeError,
 666                            "string arg to lrectwrite has wrong size");
 667                 return NULL;
 668         }
 669 #endif
 670         lrectwrite( x1 , y1 , x2 , y2 , (unsigned long *) parray );
 671         Py_INCREF(Py_None);
 672         return Py_None;
 673 }
 674
 675 % lrectread
 676
 677 static PyObject *
 678 gl_lrectread(self, args)
 679         PyObject *self;
 680         PyObject *args;
 681 {
 682         short x1 ;
 683         short y1 ;
 684         short x2 ;
 685         short y2 ;
 686         PyObject *parray;
 687         int pixcount;
 688         if (!PyArg_GetShort(args, 4, 0, &x1))
 689                 return NULL;
 690         if (!PyArg_GetShort(args, 4, 1, &y1))
 691                 return NULL;
 692         if (!PyArg_GetShort(args, 4, 2, &x2))
 693                 return NULL;
 694         if (!PyArg_GetShort(args, 4, 3, &y2))
 695                 return NULL;
 696         pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);
 697         parray = PyString_FromStringAndSize((char *)NULL, pixcount*sizeof(long));
 698         if (parray == NULL)
 699                 return NULL; /* No memory */
 700         lrectread(x1, y1, x2, y2, (unsigned long *) PyString_AsString(parray));
 701         return parray;
 702 }
 703
 704 % readdisplay
 705
 706 static PyObject *
 707 gl_readdisplay(self, args)
 708         PyObject *self;
 709         PyObject *args;
 710 {
 711         short x1, y1, x2, y2;
 712         unsigned long *parray, hints;
 713         long size, size_ret;
 714         PyObject *rv;
 715
 716         if ( !PyArg_Parse(args, "hhhhl", &x1, &y1, &x2, &y2, &hints) )
 717           return 0;
 718         size = (long)(x2+1-x1) * (long)(y2+1-y1);
 719         rv = PyString_FromStringAndSize((char *)NULL, size*sizeof(long));
 720         if ( rv == NULL )
 721           return NULL;
 722         parray = (unsigned long *)PyString_AsString(rv);
 723         size_ret = readdisplay(x1, y1, x2, y2, parray, hints);
 724         if ( size_ret != size ) {
 725             printf("gl_readdisplay: got %ld pixels, expected %ld\n",
 726                    size_ret, size);
 727             PyErr_SetString(PyExc_RuntimeError, "readdisplay returned unexpected length");
 728             return NULL;
 729         }
 730         return rv;
 731 }
 732
 733 /* Desperately needed, here are tools to compress and decompress
 734    the data manipulated by lrectread/lrectwrite.
 735
 736    gl.packrect(width, height, packfactor, bigdata) --> smalldata
 737                 makes 'bigdata' 4*(packfactor**2) times smaller by:
 738                 - turning it into B/W (a factor 4)
 739                 - replacing squares of size pacfactor by one
 740                   representative
 741
 742    gl.unpackrect(width, height, packfactor, smalldata) --> bigdata
 743                 is the inverse; the numeric arguments must be *the same*.
 744
 745    Both work best if width and height are multiples of packfactor
 746    (in fact unpackrect will leave garbage bytes).
 747 */
 748
 749 % packrect
 750
 751 static PyObject *
 752 gl_packrect(self, args)
 753         PyObject *self;
 754         PyObject *args;
 755 {
 756         long width, height, packfactor;
 757         char *s;
 758         PyObject *unpacked, *packed;
 759         int pixcount, packedcount, x, y, r, g, b;
 760         unsigned long pixel;
 761         unsigned char *p;
 762         unsigned long *parray;
 763         if (!PyArg_GetLong(args, 4, 0, &width))
 764                 return NULL;
 765         if (!PyArg_GetLong(args, 4, 1, &height))
 766                 return NULL;
 767         if (!PyArg_GetLong(args, 4, 2, &packfactor))
 768                 return NULL;
 769         if (!PyArg_GetString(args, 4, 3, &s)) /* For type checking only */
 770                 return NULL;
 771         if (!PyArg_GetObject(args, 4, 3, &unpacked))
 772                 return NULL;
 773         if (width <= 0 || height <= 0 || packfactor <= 0) {
 774                 PyErr_SetString(PyExc_RuntimeError, "packrect args must be > 0");
 775                 return NULL;
 776         }
 777         pixcount = width*height;
 778         packedcount = ((width+packfactor-1)/packfactor) *
 779                 ((height+packfactor-1)/packfactor);
 780         if (PyString_Size(unpacked) != pixcount*sizeof(long)) {
 781                 PyErr_SetString(PyExc_RuntimeError,
 782                            "string arg to packrect has wrong size");
 783                 return NULL;
 784         }
 785         packed = PyString_FromStringAndSize((char *)NULL, packedcount);
 786         if (packed == NULL)
 787                 return NULL;
 788         parray = (unsigned long *) PyString_AsString(unpacked);
 789         p = (unsigned char *) PyString_AsString(packed);
 790         for (y = 0; y < height; y += packfactor, parray += packfactor*width) {
 791                 for (x = 0; x < width; x += packfactor) {
 792                         pixel = parray[x];
 793                         r = pixel & 0xff;
 794                         g = (pixel >> 8) & 0xff;
 795                         b = (pixel >> 16) & 0xff;
 796                         *p++ = (30*r+59*g+11*b) / 100;
 797                 }
 798         }
 799         return packed;
 800 }
 801
 802 % unpackrect
 803
 804 static unsigned long unpacktab[256];
 805 static int unpacktab_inited = 0;
 806
 807 static PyObject *
 808 gl_unpackrect(self, args)
 809         PyObject *self;
 810         PyObject *args;
 811 {
 812         long width, height, packfactor;
 813         char *s;
 814         PyObject *unpacked, *packed;
 815         int pixcount, packedcount;
 816         register unsigned char *p;
 817         register unsigned long *parray;
 818         if (!unpacktab_inited) {
 819                 register int white;
 820                 for (white = 256; --white >= 0; )
 821                         unpacktab[white] = white * 0x010101L;
 822                 unpacktab_inited++;
 823         }
 824         if (!PyArg_GetLong(args, 4, 0, &width))
 825                 return NULL;
 826         if (!PyArg_GetLong(args, 4, 1, &height))
 827                 return NULL;
 828         if (!PyArg_GetLong(args, 4, 2, &packfactor))
 829                 return NULL;
 830         if (!PyArg_GetString(args, 4, 3, &s)) /* For type checking only */
 831                 return NULL;
 832         if (!PyArg_GetObject(args, 4, 3, &packed))
 833                 return NULL;
 834         if (width <= 0 || height <= 0 || packfactor <= 0) {
 835                 PyErr_SetString(PyExc_RuntimeError, "packrect args must be > 0");
 836                 return NULL;
 837         }
 838         pixcount = width*height;
 839         packedcount = ((width+packfactor-1)/packfactor) *
 840                 ((height+packfactor-1)/packfactor);
 841         if (PyString_Size(packed) != packedcount) {
 842                 PyErr_SetString(PyExc_RuntimeError,
 843                            "string arg to unpackrect has wrong size");
 844                 return NULL;
 845         }
 846         unpacked = PyString_FromStringAndSize((char *)NULL, pixcount*sizeof(long));
 847         if (unpacked == NULL)
 848                 return NULL;
 849         parray = (unsigned long *) PyString_AsString(unpacked);
 850         p = (unsigned char *) PyString_AsString(packed);
 851         if (packfactor == 1 && width*height > 0) {
 852                 /* Just expand bytes to longs */
 853                 register int x = width * height;
 854                 do {
 855                         *parray++ = unpacktab[*p++];
 856                 } while (--x >= 0);
 857         }
 858         else {
 859                 register int y;
 860                 for (y = 0; y < height-packfactor+1;
 861                      y += packfactor, parray += packfactor*width) {
 862                         register int x;
 863                         for (x = 0; x < width-packfactor+1; x += packfactor) {
 864                                 register unsigned long pixel = unpacktab[*p++];
 865                                 register int i;
 866                                 for (i = packfactor*width; (i-=width) >= 0;) {
 867                                         register int j;
 868                                         for (j = packfactor; --j >= 0; )
 869                                                 parray[i+x+j] = pixel;
 870                                 }
 871                         }
 872                 }
 873         }
 874         return unpacked;
 875 }
 876
 877 % gversion
 878 static PyObject *
 879 gl_gversion(self, args)
 880         PyObject *self;
 881         PyObject *args;
 882 {
 883         char buf[20];
 884         gversion(buf);
 885         return PyString_FromString(buf);
 886 }
 887
 888
 889 /* void clear - Manual because of clash with termcap */
 890 %clear
 891 static PyObject *
 892 gl_clear(self, args)
 893         PyObject *self;
 894         PyObject *args;
 895 {
 896         __GLclear( );
 897         Py_INCREF(Py_None);
 898         return Py_None;
 899 }
 900
 901 /* End of manually written stubs */
 902
 903 %%
 904
 905 long    getshade
 906 if !solaris     void    devport         short s long s
 907 void    rdr2i           long s long s
 908 void    rectfs          short s short s short s short s
 909 void    rects           short s short s short s short s
 910 void    rmv2i           long s long s
 911 void    noport
 912 void    popviewport
 913 void    clearhitcode
 914 void    closeobj
 915 void    cursoff
 916 void    curson
 917 void    doublebuffer
 918 void    finish
 919 void    gconfig
 920 void    ginit
 921 void    greset
 922 void    multimap
 923 void    onemap
 924 void    popattributes
 925 void    popmatrix
 926 void    pushattributes
 927 void    pushmatrix
 928 void    pushviewport
 929 void    qreset
 930 void    RGBmode
 931 void    singlebuffer
 932 void    swapbuffers
 933 void    gsync
 934 void    gflush
 935 void    tpon
 936 void    tpoff
 937 void    clkon
 938 void    clkoff
 939 void    ringbell
 940 #void   callfunc
 941 void    gbegin
 942 void    textinit
 943 void    initnames
 944 void    pclos
 945 void    popname
 946 if !solaris     void    spclos
 947 void    zclear
 948 void    screenspace
 949 void    reshapeviewport
 950 void    winpush
 951 void    winpop
 952 void    foreground
 953 void    endfullscrn
 954 if !solaris     void    endpupmode
 955 void    fullscrn
 956 if !solaris     void    pupmode
 957 void    winconstraints
 958 void    pagecolor       short s
 959 void    textcolor       short s
 960 void    color           short s
 961 void    curveit         short s
 962 void    font            short s
 963 void    linewidth       short s
 964 void    setlinestyle    short s
 965 void    setmap          short s
 966 void    swapinterval    short s
 967 void    writemask       short s
 968 if !solaris     void    textwritemask   short s
 969 void    qdevice         short s
 970 void    unqdevice       short s
 971 void    curvebasis      short s
 972 void    curveprecision  short s
 973 void    loadname        short s
 974 void    passthrough     short s
 975 void    pushname        short s
 976 void    setmonitor      short s
 977 if !solaris     void    setshade        short s
 978 void    setpattern      short s
 979 if !solaris     void    pagewritemask   short s
 980 #
 981 void    callobj         long s
 982 void    delobj          long s
 983 void    editobj         long s
 984 void    makeobj         long s
 985 void    maketag         long s
 986 void    chunksize       long s
 987 void    compactify      long s
 988 void    deltag          long s
 989 void    lsrepeat        long s
 990 void    objinsert       long s
 991 void    objreplace      long s
 992 void    winclose        long s
 993 void    blanktime       long s
 994 void    freepup         long s
 995 # This is not in the library!?
 996 ###void pupcolor        long s
 997 #
 998 void    backbuffer      long s
 999 void    frontbuffer     long s
1000 if !solaris     void    lsbackup        long s
1001 void    resetls         long s
1002 void    lampon          long s
1003 void    lampoff         long s
1004 void    setbell         long s
1005 void    blankscreen     long s
1006 void    depthcue        long s
1007 void    zbuffer         long s
1008 void    backface        long s
1009 #
1010 void    cmov2i          long s long s
1011 void    draw2i          long s long s
1012 void    move2i          long s long s
1013 void    pnt2i           long s long s
1014 void    patchbasis      long s long s
1015 void    patchprecision  long s long s
1016 void    pdr2i           long s long s
1017 void    pmv2i           long s long s
1018 void    rpdr2i          long s long s
1019 void    rpmv2i          long s long s
1020 void    xfpt2i          long s long s
1021 void    objdelete       long s long s
1022 void    patchcurves     long s long s
1023 void    minsize         long s long s
1024 void    maxsize         long s long s
1025 void    keepaspect      long s long s
1026 void    prefsize        long s long s
1027 void    stepunit        long s long s
1028 void    fudge           long s long s
1029 void    winmove         long s long s
1030 #
1031 void    attachcursor    short s short s
1032 void    deflinestyle    short s short s
1033 void    noise           short s short s
1034 void    picksize        short s short s
1035 void    qenter          short s short s
1036 void    setdepth        short s short s
1037 void    cmov2s          short s short s
1038 void    draw2s          short s short s
1039 void    move2s          short s short s
1040 void    pdr2s           short s short s
1041 void    pmv2s           short s short s
1042 void    pnt2s           short s short s
1043 void    rdr2s           short s short s
1044 void    rmv2s           short s short s
1045 void    rpdr2s          short s short s
1046 void    rpmv2s          short s short s
1047 void    xfpt2s          short s short s
1048 #
1049 void cmov2              float s float s
1050 void draw2              float s float s
1051 void move2              float s float s
1052 void pnt2               float s float s
1053 void pdr2               float s float s
1054 void pmv2               float s float s
1055 void rdr2               float s float s
1056 void rmv2               float s float s
1057 void rpdr2              float s float s
1058 void rpmv2              float s float s
1059 void xfpt2              float s float s
1060 #
1061 void loadmatrix         float s[4*4]
1062 # Really [4][4]
1063 void multmatrix         float s[4*4]
1064 # Really [4][4]
1065 void crv                        float s[3*4]
1066 # Really [4][3]
1067 void rcrv                       float s[4*4]
1068 # Really [4][4]
1069 #
1070 # Methods that have strings.
1071 #
1072 void addtopup           long s char *s long s
1073 void charstr            char *s
1074 void getport            char *s
1075 long strwidth           char *s
1076 long winopen            char *s
1077 void wintitle           char *s
1078 #
1079 # Methods that have 1 long (# of elements) and an array
1080 #
1081 void polf               long s float s[3*arg1]
1082 void polf2              long s float s[2*arg1]
1083 void poly               long s float s[3*arg1]
1084 void poly2              long s float s[2*arg1]
1085 void crvn               long s float s[3*arg1]
1086 void rcrvn              long s float s[4*arg1]
1087 #
1088 void polf2i             long s long s[2*arg1]
1089 void polfi              long s long s[3*arg1]
1090 void poly2i             long s long s[2*arg1]
1091 void polyi              long s long s[3*arg1]
1092 #
1093 void polf2s             long s short s[2*arg1]
1094 void polfs              long s short s[3*arg1]
1095 void polys              long s short s[3*arg1]
1096 void poly2s             long s short s[2*arg1]
1097 #
1098 void defcursor          short s u_short s[128]
1099 # Is this useful?
1100 void writepixels        short s u_short s[arg1]
1101 # Should be unsigned short...
1102 void defbasis           long s float s[4*4]
1103 if !solaris     void gewrite            short s short s[arg1]
1104 #
1105 void rotate             short s char s
1106 # This is not in the library!?
1107 ###void setbutton               short s char s
1108 void rot                float s char s
1109 #
1110 void circfi             long s long s long s
1111 void circi              long s long s long s
1112 void cmovi              long s long s long s
1113 void drawi              long s long s long s
1114 void movei              long s long s long s
1115 void pnti               long s long s long s
1116 void newtag             long s long s long s
1117 void pdri               long s long s long s
1118 void pmvi               long s long s long s
1119 void rdri               long s long s long s
1120 void rmvi               long s long s long s
1121 void rpdri              long s long s long s
1122 void rpmvi              long s long s long s
1123 void xfpti              long s long s long s
1124 #
1125 void circ               float s float s float s
1126 void circf              float s float s float s
1127 void cmov               float s float s float s
1128 void draw               float s float s float s
1129 void move               float s float s float s
1130 void pnt                float s float s float s
1131 void scale              float s float s float s
1132 void translate          float s float s float s
1133 void pdr                float s float s float s
1134 void pmv                float s float s float s
1135 void rdr                float s float s float s
1136 void rmv                float s float s float s
1137 void rpdr               float s float s float s
1138 void rpmv               float s float s float s
1139 void xfpt               float s float s float s
1140 #
1141 void RGBcolor           short s short s short s
1142 void RGBwritemask       short s short s short s
1143 void setcursor          short s short s short s
1144 void tie                short s short s short s
1145 void circfs             short s short s short s
1146 void circs              short s short s short s
1147 void cmovs              short s short s short s
1148 void draws              short s short s short s
1149 void moves              short s short s short s
1150 void pdrs               short s short s short s
1151 void pmvs               short s short s short s
1152 void pnts               short s short s short s
1153 void rdrs               short s short s short s
1154 void rmvs               short s short s short s
1155 void rpdrs              short s short s short s
1156 void rpmvs              short s short s short s
1157 void xfpts              short s short s short s
1158 void curorigin          short s short s short s
1159 void cyclemap           short s short s short s
1160 #
1161 void patch              float s[4*4] float s[4*4] float s[4*4]
1162 void splf               long s float s[3*arg1] u_short s[arg1]
1163 void splf2              long s float s[2*arg1] u_short s[arg1]
1164 void splfi              long s long s[3*arg1] u_short s[arg1]
1165 void splf2i             long s long s[2*arg1] u_short s[arg1]
1166 void splfs              long s short s[3*arg1] u_short s[arg1]
1167 void splf2s             long s short s[2*arg1] u_short s[arg1]
1168 ###void defpattern              short s short s u_short s[arg2*arg2/16]
1169 #
1170 void rpatch             float s[4*4] float s[4*4] float s[4*4] float s[4*4]
1171 #
1172 # routines that send 4 floats
1173 #
1174 void ortho2             float s float s float s float s
1175 void rect               float s float s float s float s
1176 void rectf              float s float s float s float s
1177 void xfpt4              float s float s float s float s
1178 #
1179 void textport           short s short s short s short s
1180 void mapcolor           short s short s short s short s
1181 void scrmask            short s short s short s short s
1182 void setvaluator        short s short s short s short s
1183 void viewport           short s short s short s short s
1184 void shaderange         short s short s short s short s
1185 void xfpt4s             short s short s short s short s
1186 void rectfi             long s long s long s long s
1187 void recti              long s long s long s long s
1188 void xfpt4i             long s long s long s long s
1189 void prefposition       long s long s long s long s
1190 #
1191 void arc                float s float s float s short s short s
1192 void arcf               float s float s float s short s short s
1193 void arcfi              long s long s long s short s short s
1194 void arci               long s long s long s short s short s
1195 #
1196 void bbox2              short s short s float s float s float s float s
1197 void bbox2i             short s short s long s long s long s long s
1198 void bbox2s             short s short s short s short s short s short s
1199 void blink              short s short s short s short s short s
1200 void ortho              float s float s float s float s float s float s
1201 void window             float s float s float s float s float s float s
1202 void lookat             float s float s float s float s float s float s short s
1203 #
1204 void perspective        short s float s float s float s
1205 void polarview          float s short s short s short s
1206 # XXX getichararray not supported
1207 #void writeRGB          short s char s[arg1] char s[arg1] char s[arg1]
1208 #
1209 void arcfs              short s short s short s short s short s
1210 void arcs               short s short s short s short s short s
1211 void rectcopy           short s short s short s short s short s short s
1212 if !solaris     void RGBcursor          short s short s short s short s short s short s short s
1213 #
1214 long getbutton          short s
1215 long getcmmode
1216 long getlsbackup
1217 long getresetls
1218 long getdcm
1219 long getzbuffer
1220 long ismex
1221 long isobj              long s
1222 long isqueued           short s
1223 long istag              long s
1224 #
1225 long genobj
1226 long gentag
1227 long getbuffer
1228 long getcolor
1229 long getdisplaymode
1230 long getfont
1231 long getheight
1232 long gethitcode
1233 long getlstyle
1234 long getlwidth
1235 long getmap
1236 long getplanes
1237 long getwritemask
1238 long qtest
1239 long getlsrepeat
1240 long getmonitor
1241 long getopenobj
1242 long getpattern
1243 long winget
1244 long winattach
1245 long getothermonitor
1246 long newpup
1247 #
1248 long getvaluator        short s
1249 void winset             long s
1250 long dopup              long s
1251 void getdepth           short r short r
1252 void getcpos            short r short r
1253 void getsize            long r long r
1254 void getorigin          long r long r
1255 void getviewport        short r short r short r short r
1256 if !solaris     void gettp              short r short r short r short r
1257 void getgpos            float r float r float r float r
1258 void winposition        long s long s long s long s
1259 void gRGBcolor          short r short r short r
1260 void gRGBmask           short r short r short r
1261 void getscrmask short r short r short r short r
1262 ###void gRGBcursor      short r short r short r short r short r short r short r short r
1263 void getmcolor          short s short r short r short r
1264 void mapw               long s short s short s float r float r float r float r float r float r
1265 void mapw2              long s short s short s float r float r
1266 ###void defrasterfont   short s short s short s Fontchar s[arg3] short s short s[4*arg5]
1267 ###long qread           short r
1268 void getcursor          short r u_short r u_short r long r
1269 #
1270 #   For these we receive arrays of stuff
1271 #
1272 ###void getdev          long s short s[arg1] short r[arg1]
1273 #XXX not generated correctly yet
1274 #void getmatrix         float r[16]
1275 ###long readpixels              short s short r[retval]
1276 ###long readRGB         short s char r[retval] char r[retval] char r[retval]
1277 ###long blkqread                short s short r[arg1]
1278 #
1279 #   New 4D routines
1280 #
1281 void cmode
1282 void concave            long s
1283 void curstype           long s
1284 void drawmode           long s
1285 void gammaramp          short s[256] short s[256] short s[256]
1286 long getbackface
1287 long getdescender
1288 long getdrawmode
1289 long getmmode
1290 long getsm
1291 long getvideo           long s
1292 void imakebackground
1293 void lmbind             short s short s
1294 void lmdef              long s long s long s float s[arg3]
1295 void mmode              long s
1296 void normal             float s[3]
1297 void overlay            long s
1298 void RGBrange           short s short s short s short s short s short s short s short s
1299 if !solaris     void setvideo           long s long s
1300 void shademodel         long s
1301 void underlay           long s
1302 #
1303 # New Personal Iris/GT Routines
1304 #
1305 void bgnclosedline
1306 void bgnline
1307 void bgnpoint
1308 void bgnpolygon
1309 void bgnsurface
1310 void bgntmesh
1311 void bgntrim
1312 void endclosedline
1313 void endline
1314 void endpoint
1315 void endpolygon
1316 void endsurface
1317 void endtmesh
1318 void endtrim
1319 void blendfunction      long s long s
1320 void c3f                float s[3]
1321 void c3i                long  s[3]
1322 void c3s                short s[3]
1323 void c4f                float s[4]
1324 void c4i                long  s[4]
1325 void c4s                short s[4]
1326 void colorf             float s
1327 void cpack              long s
1328 void czclear            long s long s
1329 void dglclose           long s
1330 long dglopen            char *s long s
1331 long getgdesc           long s
1332 void getnurbsproperty   long s float r
1333 void glcompat           long s long s
1334 void iconsize           long s long s
1335 void icontitle          char *s
1336 void lRGBrange          short s short s short s short s short s short s long s long s
1337 void linesmooth         long s
1338 void lmcolor            long s
1339 void logicop            long s
1340 ###long lrectread               short s short s short s short s long r[retval]
1341 ###void lrectwrite              short s short s short s short s long s[(arg2-arg1+1)*(arg4-arg3+1)]
1342 ### Now manual, with string last arg
1343 ###long rectread                short s short s short s short s short r[retval]
1344 ###void rectwrite               short s short s short s short s short s[(arg2-arg1+1)*(arg4-arg3+1)]
1345 void lsetdepth          long s long s
1346 void lshaderange        short s short s long s long s
1347 void n3f                float s[3]
1348 void noborder
1349 void pntsmooth          long s
1350 void readsource         long s
1351 void rectzoom           float s float s
1352 void sbox               float s float s float s float s
1353 void sboxi              long s long s long s long s
1354 void sboxs              short s short s short s short s
1355 void sboxf              float s float s float s float s
1356 void sboxfi             long s long s long s long s
1357 void sboxfs             short s short s short s short s
1358 void setnurbsproperty   long s float s
1359 void setpup             long s long s long s
1360 void smoothline         long s
1361 void subpixel           long s
1362 void swaptmesh
1363 long swinopen           long s
1364 void v2f                float s[2]
1365 void v2i                long  s[2]
1366 void v2s                short s[2]
1367 void v3f                float s[3]
1368 void v3i                long  s[3]
1369 void v3s                short s[3]
1370 void v4f                float s[4]
1371 void v4i                long  s[4]
1372 void v4s                short s[4]
1373 void videocmd           long s
1374 long windepth           long s
1375 void wmpack             long s
1376 void zdraw              long s
1377 void zfunction          long s
1378 void zsource            long s
1379 void zwritemask         long s
1380 #
1381 #   uses doubles
1382 #
1383 void v2d                double s[2]
1384 void v3d                double s[3]
1385 void v4d                double s[4]
1386 #
1387 # Why isn't this here?
1388 #
1389 void pixmode            long s long s
1390 #
1391 # New in IRIX 4.0
1392 #
1393 long qgetfd
1394 void dither             long s