1 

     2 /*

     3 Input used to generate the Python module "glmodule.c".

     4 The stub generator is a Python script called "cgen.py".

     5 

     6 Each definition must be contained on one line:

     7 

     8 <returntype> <name> <type> <arg> <type> <arg>

     9 

    10 <returntype> can be: void, short, long (XXX maybe others?)

    11 

    12 <type> can be: char, string, short, float, long, or double

    13 	string indicates a null terminated string;

    14 	if <type> is char and <arg> begins with a *, the * is stripped

    15 	and <type> is changed into string

    16 

    17 <arg> has the form <mode> or <mode>[<subscript>]

    18 	where <mode> can be

    19 		s: arg is sent

    20 		r: arg is received		(arg is a pointer)

    21 	and <subscript> can be (N and I are numbers):

    22 		N

    23 		argI

    24 		retval

    25 		N*argI

    26 		N*I

    27 		N*retval

    28 	In the case where the subscript consists of two parts

    29 	separated by *, the first part is the width of the matrix, and

    30 	the second part is the length of the matrix.  This order is

    31 	opposite from the order used in C to declare a two-dimensional

    32 	matrix.

    33 */

    34 

    35 /*

    36  * An attempt has been made to make this module switch threads on qread

    37  * calls. It is far from safe, though.

    38  */

    39 

    40 #include <gl.h>

    41 #include <device.h>

    42 

    43 #ifdef __sgi

    44 extern int devport();

    45 extern int textwritemask();

    46 extern int pagewritemask();

    47 extern int gewrite();

    48 extern int gettp();

    49 #endif

    50 

    51 #include "Python.h"

    52 #include "cgensupport.h"

    53 

    54 /*

    55 Some stubs are too complicated for the stub generator.

    56 We can include manually written versions of them here.

    57 A line starting with '%' gives the name of the function so the stub

    58 generator can include it in the table of functions.

    59 */

    60 

    61 % qread

    62 

    63 static PyObject *

    64 gl_qread(self, args)

    65 	PyObject *self;

    66 	PyObject *args;

    67 {

    68 	long retval;

    69 	short arg1 ;

    70 	Py_BEGIN_ALLOW_THREADS

    71 	retval = qread( & arg1 );

    72 	Py_END_ALLOW_THREADS

    73 	{ PyObject *v = PyTuple_New( 2 );

    74 	  if (v == NULL) return NULL;

    75 	  PyTuple_SetItem(v, 0, mknewlongobject(retval));

    76 	  PyTuple_SetItem(v, 1, mknewshortobject(arg1));

    77 	  return v;

    78 	}

    79 }

    80 

    81 

    82 /*

    83 varray -- an array of v.. calls.

    84 The argument is an array (maybe list or tuple) of points.

    85 Each point must be a tuple or list of coordinates (x, y, z).

    86 The points may be 2- or 3-dimensional but must all have the

    87 same dimension.  Float and int values may be mixed however.

    88 The points are always converted to 3D double precision points

    89 by assuming z=0.0 if necessary (as indicated in the man page),

    90 and for each point v3d() is called.

    91 */

    92 

    93 % varray

    94 

    95 static PyObject *

    96 gl_varray(self, args)

    97 	PyObject *self;

    98 	PyObject *args;

    99 {

   100 	PyObject *v, *w=NULL;

   101 	int i, n, width;

   102 	double vec[3];

   103 	PyObject * (*getitem)(PyObject *, int);

   104 	

   105 	if (!PyArg_GetObject(args, 1, 0, &v))

   106 		return NULL;

   107 	

   108 	if (PyList_Check(v)) {

   109 		n = PyList_Size(v);

   110 		getitem = PyList_GetItem;

   111 	}

   112 	else if (PyTuple_Check(v)) {

   113 		n = PyTuple_Size(v);

   114 		getitem = PyTuple_GetItem;

   115 	}

   116 	else {

   117 		PyErr_BadArgument();

   118 		return NULL;

   119 	}

   120 	

   121 	if (n == 0) {

   122 		Py_INCREF(Py_None);

   123 		return Py_None;

   124 	}

   125 	if (n > 0)

   126 		w = (*getitem)(v, 0);

   127 	

   128 	width = 0;

   129 	if (w == NULL) {

   130 	}

   131 	else if (PyList_Check(w)) {

   132 		width = PyList_Size(w);

   133 	}

   134 	else if (PyTuple_Check(w)) {

   135 		width = PyTuple_Size(w);

   136 	}

   137 	

   138 	switch (width) {

   139 	case 2:

   140 		vec[2] = 0.0;

   141 		/* Fall through */

   142 	case 3:

   143 		break;

   144 	default:

   145 		PyErr_BadArgument();

   146 		return NULL;

   147 	}

   148 	

   149 	for (i = 0; i < n; i++) {

   150 		w = (*getitem)(v, i);

   151 		if (!PyArg_GetDoubleArray(w, 1, 0, width, vec))

   152 			return NULL;

   153 		v3d(vec);

   154 	}

   155 	

   156 	Py_INCREF(Py_None);

   157 	return Py_None;

   158 }

   159 

   160 /*

   161 vnarray, nvarray -- an array of n3f and v3f calls.

   162 The argument is an array (list or tuple) of pairs of points and normals.

   163 Each pair is a tuple (NOT a list) of a point and a normal for that point.

   164 Each point or normal must be a tuple (NOT a list) of coordinates (x, y, z).

   165 Three coordinates must be given.  Float and int values may be mixed.

   166 For each pair, n3f() is called for the normal, and then v3f() is called

   167 for the vector.

   168 

   169 vnarray and nvarray differ only in the order of the vector and normal in

   170 the pair: vnarray expects (v, n) while nvarray expects (n, v).

   171 */

   172 

   173 static PyObject *gen_nvarray(); /* Forward */

   174 

   175 % nvarray

   176 

   177 static PyObject *

   178 gl_nvarray(self, args)

   179 	PyObject *self;

   180 	PyObject *args;

   181 {

   182 	return gen_nvarray(args, 0);

   183 }

   184 

   185 % vnarray

   186 

   187 static PyObject *

   188 gl_vnarray(self, args)

   189 	PyObject *self;

   190 	PyObject *args;

   191 {

   192 	return gen_nvarray(args, 1);

   193 }

   194 

   195 /* Generic, internal version of {nv,nv}array: inorm indicates the

   196    argument order, 0: normal first, 1: vector first. */

   197 

   198 static PyObject *

   199 gen_nvarray(args, inorm)

   200 	PyObject *args;

   201 	int inorm;

   202 {

   203 	PyObject *v, *w, *wnorm, *wvec;

   204 	int i, n;

   205 	float norm[3], vec[3];

   206 	PyObject * (*getitem)(PyObject *, int);

   207 	

   208 	if (!PyArg_GetObject(args, 1, 0, &v))

   209 		return NULL;

   210 	

   211 	if (PyList_Check(v)) {

   212 		n = PyList_Size(v);

   213 		getitem = PyList_GetItem;

   214 	}

   215 	else if (PyTuple_Check(v)) {

   216 		n = PyTuple_Size(v);

   217 		getitem = PyTuple_GetItem;

   218 	}

   219 	else {

   220 		PyErr_BadArgument();

   221 		return NULL;

   222 	}

   223 	

   224 	for (i = 0; i < n; i++) {

   225 		w = (*getitem)(v, i);

   226 		if (!PyTuple_Check(w) || PyTuple_Size(w) != 2) {

   227 			PyErr_BadArgument();

   228 			return NULL;

   229 		}

   230 		wnorm = PyTuple_GetItem(w, inorm);

   231 		wvec = PyTuple_GetItem(w, 1 - inorm);

   232 		if (!PyArg_GetFloatArray(wnorm, 1, 0, 3, norm) ||

   233 			!PyArg_GetFloatArray(wvec, 1, 0, 3, vec))

   234 			return NULL;

   235 		n3f(norm);

   236 		v3f(vec);

   237 	}

   238 	

   239 	Py_INCREF(Py_None);

   240 	return Py_None;

   241 }

   242 

   243 /* nurbssurface(s_knots[], t_knots[], ctl[][], s_order, t_order, type).

   244    The dimensions of ctl[] are computed as follows:

   245    [len(s_knots) - s_order], [len(t_knots) - t_order]

   246 */

   247 

   248 % nurbssurface

   249 

   250 static PyObject *

   251 gl_nurbssurface(self, args)

   252 	PyObject *self;

   253 	PyObject *args;

   254 {

   255 	long arg1 ;

   256 	double * arg2 ;

   257 	long arg3 ;

   258 	double * arg4 ;

   259 	double *arg5 ;

   260 	long arg6 ;

   261 	long arg7 ;

   262 	long arg8 ;

   263 	long ncoords;

   264 	long s_byte_stride, t_byte_stride;

   265 	long s_nctl, t_nctl;

   266 	long s, t;

   267 	PyObject *v, *w, *pt;

   268 	double *pnext;

   269 	if (!PyArg_GetLongArraySize(args, 6, 0, &arg1))

   270 		return NULL;

   271 	if ((arg2 = PyMem_NEW(double, arg1 )) == NULL) {

   272 		return PyErr_NoMemory();

   273 	}

   274 	if (!PyArg_GetDoubleArray(args, 6, 0, arg1 , arg2))

   275 		return NULL;

   276 	if (!PyArg_GetLongArraySize(args, 6, 1, &arg3))

   277 		return NULL;

   278 	if ((arg4 = PyMem_NEW(double, arg3 )) == NULL) {

   279 		return PyErr_NoMemory();

   280 	}

   281 	if (!PyArg_GetDoubleArray(args, 6, 1, arg3 , arg4))

   282 		return NULL;

   283 	if (!PyArg_GetLong(args, 6, 3, &arg6))

   284 		return NULL;

   285 	if (!PyArg_GetLong(args, 6, 4, &arg7))

   286 		return NULL;

   287 	if (!PyArg_GetLong(args, 6, 5, &arg8))

   288 		return NULL;

   289 	if (arg8 == N_XYZ)

   290 		ncoords = 3;

   291 	else if (arg8 == N_XYZW)

   292 		ncoords = 4;

   293 	else {

   294 		PyErr_BadArgument();

   295 		return NULL;

   296 	}

   297 	s_nctl = arg1 - arg6;

   298 	t_nctl = arg3 - arg7;

   299 	if (!PyArg_GetObject(args, 6, 2, &v))

   300 		return NULL;

   301 	if (!PyList_Check(v) || PyList_Size(v) != s_nctl) {

   302 		PyErr_BadArgument();

   303 		return NULL;

   304 	}

   305 	if ((arg5 = PyMem_NEW(double, s_nctl*t_nctl*ncoords )) == NULL) {

   306 		return PyErr_NoMemory();

   307 	}

   308 	pnext = arg5;

   309 	for (s = 0; s < s_nctl; s++) {

   310 		w = PyList_GetItem(v, s);

   311 		if (w == NULL || !PyList_Check(w) ||

   312 					PyList_Size(w) != t_nctl) {

   313 			PyErr_BadArgument();

   314 			return NULL;

   315 		}

   316 		for (t = 0; t < t_nctl; t++) {

   317 			pt = PyList_GetItem(w, t);

   318 			if (!PyArg_GetDoubleArray(pt, 1, 0, ncoords, pnext))

   319 				return NULL;

   320 			pnext += ncoords;

   321 		}

   322 	}

   323 	s_byte_stride = sizeof(double) * ncoords;

   324 	t_byte_stride = s_byte_stride * s_nctl;

   325 	nurbssurface( arg1 , arg2 , arg3 , arg4 ,

   326 		s_byte_stride , t_byte_stride , arg5 , arg6 , arg7 , arg8 );

   327 	PyMem_DEL(arg2);

   328 	PyMem_DEL(arg4);

   329 	PyMem_DEL(arg5);

   330 	Py_INCREF(Py_None);

   331 	return Py_None;

   332 }

   333 

   334 /* nurbscurve(knots, ctlpoints, order, type).

   335    The length of ctlpoints is len(knots)-order. */

   336 

   337 %nurbscurve

   338 

   339 static PyObject *

   340 gl_nurbscurve(self, args)

   341 	PyObject *self;

   342 	PyObject *args;

   343 {

   344 	long arg1 ;

   345 	double * arg2 ;

   346 	long arg3 ;

   347 	double * arg4 ;

   348 	long arg5 ;

   349 	long arg6 ;

   350 	int ncoords, npoints;

   351 	int i;

   352 	PyObject *v;

   353 	double *pnext;

   354 	if (!PyArg_GetLongArraySize(args, 4, 0, &arg1))

   355 		return NULL;

   356 	if ((arg2 = PyMem_NEW(double, arg1 )) == NULL) {

   357 		return PyErr_NoMemory();

   358 	}

   359 	if (!PyArg_GetDoubleArray(args, 4, 0, arg1 , arg2))

   360 		return NULL;

   361 	if (!PyArg_GetLong(args, 4, 2, &arg5))

   362 		return NULL;

   363 	if (!PyArg_GetLong(args, 4, 3, &arg6))

   364 		return NULL;

   365 	if (arg6 == N_ST)

   366 		ncoords = 2;

   367 	else if (arg6 == N_STW)

   368 		ncoords = 3;

   369 	else {

   370 		PyErr_BadArgument();

   371 		return NULL;

   372 	}

   373 	npoints = arg1 - arg5;

   374 	if (!PyArg_GetObject(args, 4, 1, &v))

   375 		return NULL;

   376 	if (!PyList_Check(v) || PyList_Size(v) != npoints) {

   377 		PyErr_BadArgument();

   378 		return NULL;

   379 	}

   380 	if ((arg4 = PyMem_NEW(double, npoints*ncoords )) == NULL) {

   381 		return PyErr_NoMemory();

   382 	}

   383 	pnext = arg4;

   384 	for (i = 0; i < npoints; i++) {

   385 		if (!PyArg_GetDoubleArray(PyList_GetItem(v, i), 1, 0, ncoords, pnext))

   386 			return NULL;

   387 		pnext += ncoords;

   388 	}

   389 	arg3 = (sizeof(double)) * ncoords;

   390 	nurbscurve( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );

   391 	PyMem_DEL(arg2);

   392 	PyMem_DEL(arg4);

   393 	Py_INCREF(Py_None);

   394 	return Py_None;

   395 }

   396 

   397 /* pwlcurve(points, type).

   398    Points is a list of points. Type must be N_ST. */

   399 

   400 %pwlcurve

   401 

   402 static PyObject *

   403 gl_pwlcurve(self, args)

   404 	PyObject *self;

   405 	PyObject *args;

   406 {

   407 	PyObject *v;

   408 	long type;

   409 	double *data, *pnext;

   410 	long npoints, ncoords;

   411 	int i;

   412 	if (!PyArg_GetObject(args, 2, 0, &v))

   413 		return NULL;

   414 	if (!PyArg_GetLong(args, 2, 1, &type))

   415 		return NULL;

   416 	if (!PyList_Check(v)) {

   417 		PyErr_BadArgument();

   418 		return NULL;

   419 	}

   420 	npoints = PyList_Size(v);

   421 	if (type == N_ST)

   422 		ncoords = 2;

   423 	else {

   424 		PyErr_BadArgument();

   425 		return NULL;

   426 	}

   427 	if ((data = PyMem_NEW(double, npoints*ncoords)) == NULL) {

   428 		return PyErr_NoMemory();

   429 	}

   430 	pnext = data;

   431 	for (i = 0; i < npoints; i++) {

   432 		if (!PyArg_GetDoubleArray(PyList_GetItem(v, i), 1, 0, ncoords, pnext))

   433 			return NULL;

   434 		pnext += ncoords;

   435 	}

   436 	pwlcurve(npoints, data, sizeof(double)*ncoords, type);

   437 	PyMem_DEL(data);

   438 	Py_INCREF(Py_None);

   439 	return Py_None;

   440 }

   441 

   442 

   443 /* Picking and Selecting */

   444 

   445 static short *pickbuffer = NULL;

   446 static long pickbuffersize;

   447 

   448 static PyObject *

   449 pick_select(args, func)

   450 	PyObject *args;

   451 	void (*func)();

   452 {

   453 	if (!PyArg_GetLong(args, 1, 0, &pickbuffersize))

   454 		return NULL;

   455 	if (pickbuffer != NULL) {

   456 		PyErr_SetString(PyExc_RuntimeError,

   457 			"pick/gselect: already picking/selecting");

   458 		return NULL;

   459 	}

   460 	if ((pickbuffer = PyMem_NEW(short, pickbuffersize)) == NULL) {

   461 		return PyErr_NoMemory();

   462 	}

   463 	(*func)(pickbuffer, pickbuffersize);

   464 	Py_INCREF(Py_None);

   465 	return Py_None;

   466 }

   467 

   468 static PyObject *

   469 endpick_select(args, func)

   470 	PyObject *args;

   471 	long (*func)();

   472 {

   473 	PyObject *v, *w;

   474 	int i, nhits, n;

   475 	if (!PyArg_NoArgs(args))

   476 		return NULL;

   477 	if (pickbuffer == NULL) {

   478 		PyErr_SetString(PyExc_RuntimeError,

   479 			"endpick/endselect: not in pick/select mode");

   480 		return NULL;

   481 	}

   482 	nhits = (*func)(pickbuffer);

   483 	if (nhits < 0) {

   484 		nhits = -nhits; /* How to report buffer overflow otherwise? */

   485 	}

   486 	/* Scan the buffer to see how many integers */

   487 	n = 0;

   488 	for (; nhits > 0; nhits--) {

   489 		n += 1 + pickbuffer[n];

   490 	}

   491 	v = PyList_New(n);

   492 	if (v == NULL)

   493 		return NULL;

   494 	/* XXX Could do it nicer and interpret the data structure here,

   495 	   returning a list of lists. But this can be done in Python... */

   496 	for (i = 0; i < n; i++) {

   497 		w = PyInt_FromLong((long)pickbuffer[i]);

   498 		if (w == NULL) {

   499 			Py_DECREF(v);

   500 			return NULL;

   501 		}

   502 		PyList_SetItem(v, i, w);

   503 	}

   504 	PyMem_DEL(pickbuffer);

   505 	pickbuffer = NULL;

   506 	return v;

   507 }

   508 

   509 extern void pick(), gselect();

   510 extern long endpick(), endselect();

   511 

   512 %pick

   513 static PyObject *gl_pick(self, args) PyObject *self, *args; {

   514 	return pick_select(args, pick);

   515 }

   516 

   517 %endpick

   518 static PyObject *gl_endpick(self, args) PyObject *self, *args; {

   519 	return endpick_select(args, endpick);

   520 }

   521 

   522 %gselect

   523 static PyObject *gl_gselect(self, args) PyObject *self, *args; {

   524 	return pick_select(args, gselect);

   525 }

   526 

   527 %endselect

   528 static PyObject *gl_endselect(self, args) PyObject *self, *args; {

   529 	return endpick_select(args, endselect);

   530 }

   531 

   532 

   533 /* XXX The generator botches this one.  Here's a quick hack to fix it. */

   534 

   535 /* XXX The generator botches this one.  Here's a quick hack to fix it. */

   536 

   537 % getmatrix float r[16]

   538 

   539 static PyObject *

   540 gl_getmatrix(self, args)

   541 	PyObject *self;

   542 	PyObject *args;

   543 {

   544 	Matrix arg1;

   545 	PyObject *v, *w;

   546 	int i, j;

   547 	getmatrix( arg1 );

   548 	v = PyList_New(16);

   549 	if (v == NULL) {

   550 		return PyErr_NoMemory();

   551 	}

   552 	for (i = 0; i < 4; i++) for (j = 0; j < 4; j++) {

   553 		w = mknewfloatobject(arg1[i][j]);

   554 		if (w == NULL) {

   555 			Py_DECREF(v);

   556 			return NULL;

   557 		}

   558 		PyList_SetItem(v, i*4+j, w);

   559 	}

   560 	return v;

   561 }

   562 

   563 /* Here's an alternate version that returns a 4x4 matrix instead of

   564    a vector.  Unfortunately it is incompatible with loadmatrix and

   565    multmatrix... */

   566 

   567 % altgetmatrix float r[4][4]

   568 

   569 static PyObject *

   570 gl_altgetmatrix(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(4);

   579 	if (v == NULL) {

   580 		return NULL;

   581 	}

   582 	for (i = 0; i < 4; i++) {

   583 		w = PyList_New(4);

   584 		if (w == NULL) {

   585 			Py_DECREF(v);

   586 			return NULL;

   587 		}

   588 		PyList_SetItem(v, i, w);

   589 	}

   590 	for (i = 0; i < 4; i++) {

   591 		for (j = 0; j < 4; j++) {

   592 			w = mknewfloatobject(arg1[i][j]);

   593 			if (w == NULL) {

   594 				Py_DECREF(v);

   595 				return NULL;

   596 			}

   597 			PyList_SetItem(PyList_GetItem(v, i), j, w);

   598 		}

   599 	}

   600 	return v;

   601 }

   602 

   603 % lrectwrite

   604 

   605 static PyObject *

   606 gl_lrectwrite(self, args)

   607 	PyObject *self;

   608 	PyObject *args;

   609 {

   610 	short x1 ;

   611 	short y1 ;

   612 	short x2 ;

   613 	short y2 ;

   614 	string parray ;

   615 	PyObject *s;

   616 #if 0

   617 	int pixcount;

   618 #endif

   619 	if (!PyArg_GetShort(args, 5, 0, &x1))

   620 		return NULL;

   621 	if (!PyArg_GetShort(args, 5, 1, &y1))

   622 		return NULL;

   623 	if (!PyArg_GetShort(args, 5, 2, &x2))

   624 		return NULL;

   625 	if (!PyArg_GetShort(args, 5, 3, &y2))

   626 		return NULL;

   627 	if (!PyArg_GetString(args, 5, 4, &parray))

   628 		return NULL;

   629 	if (!PyArg_GetObject(args, 5, 4, &s))

   630 		return NULL;

   631 #if 0

   632 /* Don't check this, it breaks experiments with pixmode(PM_SIZE, ...) */

   633 	pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);

   634 	if (!PyString_Check(s) || PyString_Size(s) != pixcount*sizeof(long)) {

   635 		PyErr_SetString(PyExc_RuntimeError,

   636 			   "string arg to lrectwrite has wrong size");

   637 		return NULL;

   638 	}

   639 #endif

   640 	lrectwrite( x1 , y1 , x2 , y2 , (unsigned long *) parray );

   641 	Py_INCREF(Py_None);

   642 	return Py_None;

   643 }

   644 

   645 % lrectread

   646 

   647 static PyObject *

   648 gl_lrectread(self, args)

   649 	PyObject *self;

   650 	PyObject *args;

   651 {

   652 	short x1 ;

   653 	short y1 ;

   654 	short x2 ;

   655 	short y2 ;

   656 	PyObject *parray;

   657 	int pixcount;

   658 	if (!PyArg_GetShort(args, 4, 0, &x1))

   659 		return NULL;

   660 	if (!PyArg_GetShort(args, 4, 1, &y1))

   661 		return NULL;

   662 	if (!PyArg_GetShort(args, 4, 2, &x2))

   663 		return NULL;

   664 	if (!PyArg_GetShort(args, 4, 3, &y2))

   665 		return NULL;

   666 	pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);

   667 	parray = PyString_FromStringAndSize((char *)NULL, pixcount*sizeof(long));

   668 	if (parray == NULL)

   669 		return NULL; /* No memory */

   670 	lrectread(x1, y1, x2, y2, (unsigned long *) PyString_AsString(parray));

   671 	return parray;

   672 }

   673 

   674 % readdisplay

   675 

   676 static PyObject *

   677 gl_readdisplay(self, args)

   678 	PyObject *self;

   679         PyObject *args;

   680 {

   681         short x1, y1, x2, y2;

   682 	unsigned long *parray, hints;

   683 	long size, size_ret;

   684 	PyObject *rv;

   685 

   686 	if ( !PyArg_Parse(args, "hhhhl", &x1, &y1, &x2, &y2, &hints) )

   687 	  return 0;

   688 	size = (long)(x2+1-x1) * (long)(y2+1-y1);

   689 	rv = PyString_FromStringAndSize((char *)NULL, size*sizeof(long));

   690 	if ( rv == NULL )

   691 	  return NULL;

   692 	parray = (unsigned long *)PyString_AsString(rv);

   693 	size_ret = readdisplay(x1, y1, x2, y2, parray, hints);

   694 	if ( size_ret != size ) {

   695 	    printf("gl_readdisplay: got %ld pixels, expected %ld\n",

   696 		   size_ret, size);

   697 	    PyErr_SetString(PyExc_RuntimeError, "readdisplay returned unexpected length");

   698 	    return NULL;

   699 	}

   700 	return rv;

   701 }

   702 

   703 /* Desperately needed, here are tools to compress and decompress

   704    the data manipulated by lrectread/lrectwrite.

   705 

   706    gl.packrect(width, height, packfactor, bigdata) --> smalldata

   707 		makes 'bigdata' 4*(packfactor**2) times smaller by:

   708 		- turning it into B/W (a factor 4)

   709 		- replacing squares of size pacfactor by one

   710 		  representative

   711 

   712    gl.unpackrect(width, height, packfactor, smalldata) --> bigdata

   713 		is the inverse; the numeric arguments must be *the same*.

   714 

   715    Both work best if width and height are multiples of packfactor

   716    (in fact unpackrect will leave garbage bytes).

   717 */

   718 

   719 % packrect

   720 

   721 static PyObject *

   722 gl_packrect(self, args)

   723 	PyObject *self;

   724 	PyObject *args;

   725 {

   726 	long width, height, packfactor;

   727 	char *s;

   728 	PyObject *unpacked, *packed;

   729 	int pixcount, packedcount, x, y, r, g, b;

   730 	unsigned long pixel;

   731 	unsigned char *p;

   732 	unsigned long *parray;

   733 	if (!PyArg_GetLong(args, 4, 0, &width))

   734 		return NULL;

   735 	if (!PyArg_GetLong(args, 4, 1, &height))

   736 		return NULL;

   737 	if (!PyArg_GetLong(args, 4, 2, &packfactor))

   738 		return NULL;

   739 	if (!PyArg_GetString(args, 4, 3, &s)) /* For type checking only */

   740 		return NULL;

   741 	if (!PyArg_GetObject(args, 4, 3, &unpacked))

   742 		return NULL;

   743 	if (width <= 0 || height <= 0 || packfactor <= 0) {

   744 		PyErr_SetString(PyExc_RuntimeError, "packrect args must be > 0");

   745 		return NULL;

   746 	}

   747 	pixcount = width*height;

   748 	packedcount = ((width+packfactor-1)/packfactor) *

   749 		((height+packfactor-1)/packfactor);

   750 	if (PyString_Size(unpacked) != pixcount*sizeof(long)) {

   751 		PyErr_SetString(PyExc_RuntimeError,

   752 			   "string arg to packrect has wrong size");

   753 		return NULL;

   754 	}

   755 	packed = PyString_FromStringAndSize((char *)NULL, packedcount);

   756 	if (packed == NULL)

   757 		return NULL;

   758 	parray = (unsigned long *) PyString_AsString(unpacked);

   759 	p = (unsigned char *) PyString_AsString(packed);

   760 	for (y = 0; y < height; y += packfactor, parray += packfactor*width) {

   761 		for (x = 0; x < width; x += packfactor) {

   762 			pixel = parray[x];

   763 			r = pixel & 0xff;

   764 			g = (pixel >> 8) & 0xff;

   765 			b = (pixel >> 16) & 0xff;

   766 			*p++ = (30*r+59*g+11*b) / 100;

   767 		}

   768 	}

   769 	return packed;

   770 }

   771 

   772 % unpackrect

   773 

   774 static unsigned long unpacktab[256];

   775 static int unpacktab_inited = 0;

   776 

   777 static PyObject *

   778 gl_unpackrect(self, args)

   779 	PyObject *self;

   780 	PyObject *args;

   781 {

   782 	long width, height, packfactor;

   783 	char *s;

   784 	PyObject *unpacked, *packed;

   785 	int pixcount, packedcount;

   786 	register unsigned char *p;

   787 	register unsigned long *parray;

   788 	if (!unpacktab_inited) {

   789 		register int white;

   790 		for (white = 256; --white >= 0; )

   791 			unpacktab[white] = white * 0x010101L;

   792 		unpacktab_inited++;

   793 	}

   794 	if (!PyArg_GetLong(args, 4, 0, &width))

   795 		return NULL;

   796 	if (!PyArg_GetLong(args, 4, 1, &height))

   797 		return NULL;

   798 	if (!PyArg_GetLong(args, 4, 2, &packfactor))

   799 		return NULL;

   800 	if (!PyArg_GetString(args, 4, 3, &s)) /* For type checking only */

   801 		return NULL;

   802 	if (!PyArg_GetObject(args, 4, 3, &packed))

   803 		return NULL;

   804 	if (width <= 0 || height <= 0 || packfactor <= 0) {

   805 		PyErr_SetString(PyExc_RuntimeError, "packrect args must be > 0");

   806 		return NULL;

   807 	}

   808 	pixcount = width*height;

   809 	packedcount = ((width+packfactor-1)/packfactor) *

   810 		((height+packfactor-1)/packfactor);

   811 	if (PyString_Size(packed) != packedcount) {

   812 		PyErr_SetString(PyExc_RuntimeError,

   813 			   "string arg to unpackrect has wrong size");

   814 		return NULL;

   815 	}

   816 	unpacked = PyString_FromStringAndSize((char *)NULL, pixcount*sizeof(long));

   817 	if (unpacked == NULL)

   818 		return NULL;

   819 	parray = (unsigned long *) PyString_AsString(unpacked);

   820 	p = (unsigned char *) PyString_AsString(packed);

   821 	if (packfactor == 1 && width*height > 0) {

   822 		/* Just expand bytes to longs */

   823 		register int x = width * height;

   824 		do {

   825 			*parray++ = unpacktab[*p++];

   826 		} while (--x >= 0);

   827 	}

   828 	else {

   829 		register int y;

   830 		for (y = 0; y < height-packfactor+1;

   831 		     y += packfactor, parray += packfactor*width) {

   832 			register int x;

   833 			for (x = 0; x < width-packfactor+1; x += packfactor) {

   834 				register unsigned long pixel = unpacktab[*p++];

   835 				register int i;

   836 				for (i = packfactor*width; (i-=width) >= 0;) {

   837 					register int j;

   838 					for (j = packfactor; --j >= 0; )

   839 						parray[i+x+j] = pixel;

   840 				}

   841 			}

   842 		}

   843 	}

   844 	return unpacked;

   845 }

   846 

   847 % gversion

   848 static PyObject *

   849 gl_gversion(self, args)

   850 	PyObject *self;

   851 	PyObject *args;

   852 {

   853 	char buf[20];

   854 	gversion(buf);

   855 	return PyString_FromString(buf);

   856 }

   857 

   858 

   859 /* void clear - Manual because of clash with termcap */

   860 %clear

   861 static PyObject *

   862 gl_clear(self, args)

   863 	PyObject *self;

   864 	PyObject *args;

   865 {

   866 	__GLclear( );

   867 	Py_INCREF(Py_None);

   868 	return Py_None;

   869 }

   870 

   871 /* End of manually written stubs */

   872 

   873 %%

   874 

   875 long 	getshade

   876 if !solaris	void 	devport 	short s long s

   877 void 	rdr2i 		long s long s

   878 void	rectfs 		short s short s short s short s

   879 void 	rects 		short s short s short s short s

   880 void 	rmv2i 		long s long s

   881 void	noport

   882 void	popviewport

   883 void	clearhitcode

   884 void	closeobj

   885 void	cursoff

   886 void	curson

   887 void	doublebuffer

   888 void 	finish

   889 void	gconfig

   890 void	ginit

   891 void	greset

   892 void	multimap

   893 void	onemap

   894 void	popattributes

   895 void	popmatrix

   896 void	pushattributes

   897 void	pushmatrix

   898 void	pushviewport

   899 void	qreset

   900 void	RGBmode

   901 void	singlebuffer

   902 void	swapbuffers

   903 void	gsync

   904 void	gflush

   905 void	tpon

   906 void	tpoff

   907 void	clkon

   908 void	clkoff

   909 void	ringbell

   910 #void	callfunc

   911 void	gbegin

   912 void	textinit

   913 void	initnames

   914 void	pclos

   915 void	popname

   916 if !solaris	void	spclos

   917 void	zclear

   918 void	screenspace

   919 void	reshapeviewport

   920 void	winpush

   921 void	winpop

   922 void	foreground

   923 void	endfullscrn

   924 if !solaris	void	endpupmode

   925 void	fullscrn

   926 if !solaris	void	pupmode

   927 void	winconstraints

   928 void	pagecolor 	short s

   929 void	textcolor 	short s

   930 void 	color 	  	short s

   931 void	curveit		short s

   932 void	font		short s

   933 void 	linewidth	short s

   934 void    setlinestyle	short s

   935 void	setmap		short s

   936 void	swapinterval	short s

   937 void	writemask	short s

   938 if !solaris	void	textwritemask	short s

   939 void	qdevice		short s

   940 void	unqdevice	short s

   941 void	curvebasis	short s

   942 void	curveprecision	short s

   943 void	loadname	short s

   944 void	passthrough	short s

   945 void	pushname	short s

   946 void	setmonitor	short s

   947 if !solaris	void	setshade	short s

   948 void	setpattern	short s

   949 if !solaris	void	pagewritemask	short s

   950 #

   951 void	callobj		long s

   952 void	delobj		long s

   953 void 	editobj		long s

   954 void	makeobj		long s

   955 void	maketag		long s

   956 void	chunksize	long s

   957 void	compactify	long s

   958 void	deltag		long s

   959 void	lsrepeat	long s

   960 void	objinsert	long s

   961 void 	objreplace	long s

   962 void	winclose	long s

   963 void	blanktime	long s

   964 void 	freepup		long s

   965 # This is not in the library!?

   966 ###void	pupcolor	long s

   967 #

   968 void	backbuffer	long s

   969 void 	frontbuffer	long s

   970 if !solaris	void	lsbackup	long s

   971 void	resetls		long s

   972 void	lampon		long s

   973 void	lampoff		long s

   974 void	setbell		long s

   975 void	blankscreen	long s

   976 void 	depthcue	long s

   977 void	zbuffer		long s

   978 void	backface	long s

   979 #

   980 void 	cmov2i		long s long s

   981 void 	draw2i		long s long s

   982 void	move2i		long s long s

   983 void	pnt2i		long s long s

   984 void 	patchbasis	long s long s

   985 void 	patchprecision	long s long s

   986 void	pdr2i		long s long s

   987 void	pmv2i		long s long s

   988 void	rpdr2i		long s long s

   989 void	rpmv2i		long s long s

   990 void	xfpt2i		long s long s

   991 void	objdelete	long s long s

   992 void	patchcurves	long s long s

   993 void	minsize		long s long s

   994 void 	maxsize		long s long s

   995 void	keepaspect	long s long s

   996 void	prefsize	long s long s

   997 void	stepunit	long s long s

   998 void 	fudge		long s long s

   999 void 	winmove		long s long s

  1000 #

  1001 void 	attachcursor	short s short s

  1002 void 	deflinestyle	short s short s

  1003 void 	noise		short s short s

  1004 void 	picksize	short s short s

  1005 void 	qenter		short s short s

  1006 void 	setdepth	short s short s

  1007 void 	cmov2s		short s short s

  1008 void 	draw2s		short s	short s

  1009 void 	move2s		short s short s

  1010 void 	pdr2s		short s short s

  1011 void 	pmv2s		short s short s

  1012 void 	pnt2s		short s short s

  1013 void 	rdr2s		short s short s

  1014 void 	rmv2s		short s short s

  1015 void 	rpdr2s		short s short s

  1016 void 	rpmv2s		short s short s

  1017 void 	xfpt2s		short s short s

  1018 #

  1019 void cmov2		float s float s

  1020 void draw2		float s float s

  1021 void move2		float s float s

  1022 void pnt2		float s float s

  1023 void pdr2		float s float s

  1024 void pmv2		float s float s

  1025 void rdr2		float s float s

  1026 void rmv2		float s float s

  1027 void rpdr2		float s float s

  1028 void rpmv2		float s float s

  1029 void xfpt2		float s float s

  1030 #

  1031 void loadmatrix		float s[4*4]

  1032 # Really [4][4]

  1033 void multmatrix		float s[4*4]

  1034 # Really [4][4]

  1035 void crv			float s[3*4]

  1036 # Really [4][3]

  1037 void rcrv			float s[4*4]

  1038 # Really [4][4]

  1039 #

  1040 # Methods that have strings.  

  1041 #

  1042 void addtopup		long s char *s long s

  1043 void charstr		char *s

  1044 void getport	 	char *s

  1045 long strwidth		char *s

  1046 long winopen		char *s

  1047 void wintitle		char *s

  1048 #

  1049 # Methods that have 1 long (# of elements) and an array 

  1050 #

  1051 void polf		long s float s[3*arg1]

  1052 void polf2		long s float s[2*arg1]

  1053 void poly		long s float s[3*arg1]

  1054 void poly2		long s float s[2*arg1]

  1055 void crvn		long s float s[3*arg1]

  1056 void rcrvn		long s float s[4*arg1]

  1057 #

  1058 void polf2i		long s long s[2*arg1]

  1059 void polfi		long s long s[3*arg1]

  1060 void poly2i		long s long s[2*arg1]

  1061 void polyi		long s long s[3*arg1]

  1062 #

  1063 void polf2s		long s short s[2*arg1]

  1064 void polfs		long s short s[3*arg1]

  1065 void polys		long s short s[3*arg1]

  1066 void poly2s		long s short s[2*arg1]

  1067 #

  1068 void defcursor		short s u_short s[128]

  1069 # Is this useful?

  1070 void writepixels	short s u_short s[arg1]

  1071 # Should be unsigned short...

  1072 void defbasis		long s float s[4*4]

  1073 if !solaris	void gewrite		short s short s[arg1]

  1074 #

  1075 void rotate		short s char s

  1076 # This is not in the library!?

  1077 ###void setbutton		short s char s

  1078 void rot		float s char s

  1079 #

  1080 void circfi		long s long s long s

  1081 void circi		long s long s long s

  1082 void cmovi		long s long s long s

  1083 void drawi		long s long s long s

  1084 void movei		long s long s long s

  1085 void pnti 		long s long s long s

  1086 void newtag		long s long s long s

  1087 void pdri  		long s long s long s

  1088 void pmvi  		long s long s long s

  1089 void rdri  		long s long s long s

  1090 void rmvi  		long s long s long s

  1091 void rpdri 		long s long s long s

  1092 void rpmvi 		long s long s long s

  1093 void xfpti 		long s long s long s

  1094 #

  1095 void circ		float s float s float s

  1096 void circf		float s float s float s

  1097 void cmov		float s float s float s

  1098 void draw		float s float s float s

  1099 void move		float s float s float s

  1100 void pnt		float s float s float s

  1101 void scale		float s float s float s

  1102 void translate		float s float s float s

  1103 void pdr		float s float s float s

  1104 void pmv		float s float s float s

  1105 void rdr		float s float s float s

  1106 void rmv		float s float s float s

  1107 void rpdr		float s float s float s

  1108 void rpmv		float s float s float s

  1109 void xfpt		float s float s float s

  1110 #

  1111 void RGBcolor		short s short s short s

  1112 void RGBwritemask	short s short s short s

  1113 void setcursor		short s short s short s

  1114 void tie		short s short s short s

  1115 void circfs		short s short s short s

  1116 void circs		short s short s short s

  1117 void cmovs		short s short s short s

  1118 void draws		short s short s short s

  1119 void moves		short s short s short s

  1120 void pdrs		short s short s short s

  1121 void pmvs		short s short s short s

  1122 void pnts		short s short s short s

  1123 void rdrs		short s short s short s

  1124 void rmvs		short s short s short s

  1125 void rpdrs		short s short s short s

  1126 void rpmvs		short s short s short s

  1127 void xfpts		short s short s short s

  1128 void curorigin		short s short s short s

  1129 void cyclemap		short s short s short s

  1130 #

  1131 void patch		float s[4*4] float s[4*4] float s[4*4]

  1132 void splf		long s float s[3*arg1] u_short s[arg1]

  1133 void splf2		long s float s[2*arg1] u_short s[arg1]

  1134 void splfi		long s long s[3*arg1] u_short s[arg1]

  1135 void splf2i		long s long s[2*arg1] u_short s[arg1]