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 

    62 static PyObject *

    63 gl_qread(PyObject *self, PyObject *args)

    64 {

    65 	long retval;

    66 	short arg1 ;

    67 	Py_BEGIN_ALLOW_THREADS

    68 	retval = qread( & arg1 );

    69 	Py_END_ALLOW_THREADS

    70 	{ PyObject *v = PyTuple_New( 2 );

    71 	  if (v == NULL) return NULL;

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

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

    74 	  return v;

    75 	}

    76 }

    77 

    78 

    79 /*

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

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

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

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

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

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

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

    87 and for each point v3d() is called.

    88 */

    89 

    90 

    91 static PyObject *

    92 gl_varray(PyObject *self, PyObject *args)

    93 {

    94 	PyObject *v, *w=NULL;

    95 	int i, n, width;

    96 	double vec[3];

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

    98 	

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

   100 		return NULL;

   101 	

   102 	if (PyList_Check(v)) {

   103 		n = PyList_Size(v);

   104 		getitem = PyList_GetItem;

   105 	}

   106 	else if (PyTuple_Check(v)) {

   107 		n = PyTuple_Size(v);

   108 		getitem = PyTuple_GetItem;

   109 	}

   110 	else {

   111 		PyErr_BadArgument();

   112 		return NULL;

   113 	}

   114 	

   115 	if (n == 0) {

   116 		Py_INCREF(Py_None);

   117 		return Py_None;

   118 	}

   119 	if (n > 0)

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

   121 	

   122 	width = 0;

   123 	if (w == NULL) {

   124 	}

   125 	else if (PyList_Check(w)) {

   126 		width = PyList_Size(w);

   127 	}

   128 	else if (PyTuple_Check(w)) {

   129 		width = PyTuple_Size(w);

   130 	}

   131 	

   132 	switch (width) {

   133 	case 2:

   134 		vec[2] = 0.0;

   135 		/* Fall through */

   136 	case 3:

   137 		break;

   138 	default:

   139 		PyErr_BadArgument();

   140 		return NULL;

   141 	}

   142 	

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

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

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

   146 			return NULL;

   147 		v3d(vec);

   148 	}

   149 	

   150 	Py_INCREF(Py_None);

   151 	return Py_None;

   152 }

   153 

   154 /*

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

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

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

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

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

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

   161 for the vector.

   162 

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

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

   165 */

   166 

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

   168 

   169 

   170 static PyObject *

   171 gl_nvarray(PyObject *self, PyObject *args)

   172 {

   173 	return gen_nvarray(args, 0);

   174 }

   175 

   176 

   177 static PyObject *

   178 gl_vnarray(PyObject *self, PyObject *args)

   179 {

   180 	return gen_nvarray(args, 1);

   181 }

   182 

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

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

   185 

   186 static PyObject *

   187 gen_nvarray(PyObject *args, int inorm)

   188 {

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

   190 	int i, n;

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

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

   193 	

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

   195 		return NULL;

   196 	

   197 	if (PyList_Check(v)) {

   198 		n = PyList_Size(v);

   199 		getitem = PyList_GetItem;

   200 	}

   201 	else if (PyTuple_Check(v)) {

   202 		n = PyTuple_Size(v);

   203 		getitem = PyTuple_GetItem;

   204 	}

   205 	else {

   206 		PyErr_BadArgument();

   207 		return NULL;

   208 	}

   209 	

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

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

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

   213 			PyErr_BadArgument();

   214 			return NULL;

   215 		}

   216 		wnorm = PyTuple_GetItem(w, inorm);

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

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

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

   220 			return NULL;

   221 		n3f(norm);

   222 		v3f(vec);

   223 	}

   224 	

   225 	Py_INCREF(Py_None);

   226 	return Py_None;

   227 }

   228 

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

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

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

   232 */

   233 

   234 

   235 static PyObject *

   236 gl_nurbssurface(PyObject *self, PyObject *args)

   237 {

   238 	long arg1 ;

   239 	double * arg2 ;

   240 	long arg3 ;

   241 	double * arg4 ;

   242 	double *arg5 ;

   243 	long arg6 ;

   244 	long arg7 ;

   245 	long arg8 ;

   246 	long ncoords;

   247 	long s_byte_stride, t_byte_stride;

   248 	long s_nctl, t_nctl;

   249 	long s, t;

   250 	PyObject *v, *w, *pt;

   251 	double *pnext;

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

   253 		return NULL;

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

   255 		return PyErr_NoMemory();

   256 	}

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

   258 		return NULL;

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

   260 		return NULL;

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

   262 		return PyErr_NoMemory();

   263 	}

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

   265 		return NULL;

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

   267 		return NULL;

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

   269 		return NULL;

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

   271 		return NULL;

   272 	if (arg8 == N_XYZ)

   273 		ncoords = 3;

   274 	else if (arg8 == N_XYZW)

   275 		ncoords = 4;

   276 	else {

   277 		PyErr_BadArgument();

   278 		return NULL;

   279 	}

   280 	s_nctl = arg1 - arg6;

   281 	t_nctl = arg3 - arg7;

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

   283 		return NULL;

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

   285 		PyErr_BadArgument();

   286 		return NULL;

   287 	}

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

   289 		return PyErr_NoMemory();

   290 	}

   291 	pnext = arg5;

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

   293 		w = PyList_GetItem(v, s);

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

   295 					PyList_Size(w) != t_nctl) {

   296 			PyErr_BadArgument();

   297 			return NULL;

   298 		}

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

   300 			pt = PyList_GetItem(w, t);

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

   302 				return NULL;

   303 			pnext += ncoords;

   304 		}

   305 	}

   306 	s_byte_stride = sizeof(double) * ncoords;

   307 	t_byte_stride = s_byte_stride * s_nctl;

   308 	nurbssurface( arg1 , arg2 , arg3 , arg4 ,

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

   310 	PyMem_DEL(arg2);

   311 	PyMem_DEL(arg4);

   312 	PyMem_DEL(arg5);

   313 	Py_INCREF(Py_None);

   314 	return Py_None;

   315 }

   316 

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

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

   319 

   320 

   321 static PyObject *

   322 gl_nurbscurve(PyObject *self, PyObject *args)

   323 {

   324 	long arg1 ;

   325 	double * arg2 ;

   326 	long arg3 ;

   327 	double * arg4 ;

   328 	long arg5 ;

   329 	long arg6 ;

   330 	int ncoords, npoints;

   331 	int i;

   332 	PyObject *v;

   333 	double *pnext;

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

   335 		return NULL;

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

   337 		return PyErr_NoMemory();

   338 	}

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

   340 		return NULL;

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

   342 		return NULL;

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

   344 		return NULL;

   345 	if (arg6 == N_ST)

   346 		ncoords = 2;

   347 	else if (arg6 == N_STW)

   348 		ncoords = 3;

   349 	else {

   350 		PyErr_BadArgument();

   351 		return NULL;

   352 	}

   353 	npoints = arg1 - arg5;

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

   355 		return NULL;

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

   357 		PyErr_BadArgument();

   358 		return NULL;

   359 	}

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

   361 		return PyErr_NoMemory();

   362 	}

   363 	pnext = arg4;

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

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

   366 			return NULL;

   367 		pnext += ncoords;

   368 	}

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

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

   371 	PyMem_DEL(arg2);

   372 	PyMem_DEL(arg4);

   373 	Py_INCREF(Py_None);

   374 	return Py_None;

   375 }

   376 

   377 /* pwlcurve(points, type).

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

   379 

   380 

   381 static PyObject *

   382 gl_pwlcurve(PyObject *self, PyObject *args)

   383 {

   384 	PyObject *v;

   385 	long type;

   386 	double *data, *pnext;

   387 	long npoints, ncoords;

   388 	int i;

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

   390 		return NULL;

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

   392 		return NULL;

   393 	if (!PyList_Check(v)) {

   394 		PyErr_BadArgument();

   395 		return NULL;

   396 	}

   397 	npoints = PyList_Size(v);

   398 	if (type == N_ST)

   399 		ncoords = 2;

   400 	else {

   401 		PyErr_BadArgument();

   402 		return NULL;

   403 	}

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

   405 		return PyErr_NoMemory();

   406 	}

   407 	pnext = data;

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

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

   410 			return NULL;

   411 		pnext += ncoords;

   412 	}

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

   414 	PyMem_DEL(data);

   415 	Py_INCREF(Py_None);

   416 	return Py_None;

   417 }

   418 

   419 

   420 /* Picking and Selecting */

   421 

   422 static short *pickbuffer = NULL;

   423 static long pickbuffersize;

   424 

   425 static PyObject *

   426 pick_select(PyObject *args, void (*func)())

   427 {

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

   429 		return NULL;

   430 	if (pickbuffer != NULL) {

   431 		PyErr_SetString(PyExc_RuntimeError,

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

   433 		return NULL;

   434 	}

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

   436 		return PyErr_NoMemory();

   437 	}

   438 	(*func)(pickbuffer, pickbuffersize);

   439 	Py_INCREF(Py_None);

   440 	return Py_None;

   441 }

   442 

   443 static PyObject *

   444 endpick_select(long (*func)())

   445 {

   446 	PyObject *v, *w;

   447 	int i, nhits, n;

   448 	if (pickbuffer == NULL) {

   449 		PyErr_SetString(PyExc_RuntimeError,

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

   451 		return NULL;

   452 	}

   453 	nhits = (*func)(pickbuffer);

   454 	if (nhits < 0) {

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

   456 	}

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

   458 	n = 0;

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

   460 		n += 1 + pickbuffer[n];

   461 	}

   462 	v = PyList_New(n);

   463 	if (v == NULL)

   464 		return NULL;

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

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

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

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

   469 		if (w == NULL) {

   470 			Py_DECREF(v);

   471 			return NULL;

   472 		}

   473 		PyList_SetItem(v, i, w);

   474 	}

   475 	PyMem_DEL(pickbuffer);

   476 	pickbuffer = NULL;

   477 	return v;

   478 }

   479 

   480 extern void pick(), gselect();

   481 extern long endpick(), endselect();

   482 

   483 static PyObject *gl_pick(PyObject *self, PyObject *args)

   484 {

   485 	return pick_select(args, pick);

   486 }

   487 

   488 static PyObject *gl_endpick(PyObject *self)

   489 {

   490 	return endpick_select(endpick);

   491 }

   492 

   493 static PyObject *gl_gselect(PyObject *self, PyObject *args)

   494 {

   495 	return pick_select(args, gselect);

   496 }

   497 

   498 static PyObject *gl_endselect(PyObject *self)

   499 {

   500 	return endpick_select(endselect);

   501 }

   502 

   503 

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

   505 

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

   507 

   508 

   509 static PyObject *

   510 gl_getmatrix(PyObject *self, PyObject *args)

   511 {

   512 	Matrix arg1;

   513 	PyObject *v, *w;

   514 	int i, j;

   515 	getmatrix( arg1 );

   516 	v = PyList_New(16);

   517 	if (v == NULL) {

   518 		return PyErr_NoMemory();

   519 	}

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

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

   522 		if (w == NULL) {

   523 			Py_DECREF(v);

   524 			return NULL;

   525 		}

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

   527 	}

   528 	return v;

   529 }

   530 

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

   532    a vector.  Unfortunately it is incompatible with loadmatrix and

   533    multmatrix... */

   534 

   535 

   536 static PyObject *

   537 gl_altgetmatrix(PyObject *self, PyObject *args)

   538 {

   539 	Matrix arg1;

   540 	PyObject *v, *w;

   541 	int i, j;

   542 	getmatrix( arg1 );

   543 	v = PyList_New(4);

   544 	if (v == NULL) {

   545 		return NULL;

   546 	}

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

   548 		w = PyList_New(4);

   549 		if (w == NULL) {

   550 			Py_DECREF(v);

   551 			return NULL;

   552 		}

   553 		PyList_SetItem(v, i, w);

   554 	}

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

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

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

   558 			if (w == NULL) {

   559 				Py_DECREF(v);

   560 				return NULL;

   561 			}

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

   563 		}

   564 	}

   565 	return v;

   566 }

   567 

   568 

   569 static PyObject *

   570 gl_lrectwrite(PyObject *self, PyObject *args)

   571 {

   572 	short x1 ;

   573 	short y1 ;

   574 	short x2 ;

   575 	short y2 ;

   576 	string parray ;

   577 	PyObject *s;

   578 #if 0

   579 	int pixcount;

   580 #endif

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

   582 		return NULL;

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

   584 		return NULL;

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

   586 		return NULL;

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

   588 		return NULL;

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

   590 		return NULL;

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

   592 		return NULL;

   593 #if 0

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

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

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

   597 		PyErr_SetString(PyExc_RuntimeError,

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

   599 		return NULL;

   600 	}

   601 #endif

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

   603 	Py_INCREF(Py_None);

   604 	return Py_None;

   605 }

   606 

   607 

   608 static PyObject *

   609 gl_lrectread(PyObject *self, PyObject *args)

   610 {

   611 	short x1 ;

   612 	short y1 ;

   613 	short x2 ;

   614 	short y2 ;

   615 	PyObject *parray;

   616 	int pixcount;

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

   618 		return NULL;

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

   620 		return NULL;

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

   622 		return NULL;

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

   624 		return NULL;

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

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

   627 	if (parray == NULL)

   628 		return NULL; /* No memory */

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

   630 	return parray;

   631 }

   632 

   633 

   634 static PyObject *

   635 gl_readdisplay(PyObject *self, PyObject *args)

   636 {

   637         short x1, y1, x2, y2;

   638 	unsigned long *parray, hints;

   639 	long size, size_ret;

   640 	PyObject *rv;

   641 

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

   643 	  return 0;

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

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

   646 	if ( rv == NULL )

   647 	  return NULL;

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

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

   650 	if ( size_ret != size ) {

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

   652 		   size_ret, size);

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

   654 	    return NULL;

   655 	}

   656 	return rv;

   657 }

   658 

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

   660    the data manipulated by lrectread/lrectwrite.

   661 

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

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

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

   665 		- replacing squares of size pacfactor by one

   666 		  representative

   667 

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

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

   670 

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

   672    (in fact unpackrect will leave garbage bytes).

   673 */

   674 

   675 

   676 static PyObject *

   677 gl_packrect(PyObject *self, PyObject *args)

   678 {

   679 	long width, height, packfactor;

   680 	char *s;

   681 	PyObject *unpacked, *packed;

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

   683 	unsigned long pixel;

   684 	unsigned char *p;

   685 	unsigned long *parray;

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

   687 		return NULL;

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

   689 		return NULL;

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

   691 		return NULL;

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

   693 		return NULL;

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

   695 		return NULL;

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

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

   698 		return NULL;

   699 	}

   700 	pixcount = width*height;

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

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

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

   704 		PyErr_SetString(PyExc_RuntimeError,

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

   706 		return NULL;

   707 	}

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

   709 	if (packed == NULL)

   710 		return NULL;

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

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

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

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

   715 			pixel = parray[x];

   716 			r = pixel & 0xff;

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

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

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

   720 		}

   721 	}

   722 	return packed;

   723 }

   724 

   725 

   726 static unsigned long unpacktab[256];

   727 static int unpacktab_inited = 0;

   728 

   729 static PyObject *

   730 gl_unpackrect(PyObject *self, PyObject *args)

   731 {

   732 	long width, height, packfactor;

   733 	char *s;

   734 	PyObject *unpacked, *packed;

   735 	int pixcount, packedcount;

   736 	register unsigned char *p;

   737 	register unsigned long *parray;

   738 	if (!unpacktab_inited) {

   739 		register int white;

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

   741 			unpacktab[white] = white * 0x010101L;

   742 		unpacktab_inited++;

   743 	}

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

   745 		return NULL;

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

   747 		return NULL;

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

   749 		return NULL;

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

   751 		return NULL;

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

   753 		return NULL;

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

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

   756 		return NULL;

   757 	}

   758 	pixcount = width*height;

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

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

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

   762 		PyErr_SetString(PyExc_RuntimeError,

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

   764 		return NULL;

   765 	}

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

   767 	if (unpacked == NULL)

   768 		return NULL;

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

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

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

   772 		/* Just expand bytes to longs */

   773 		register int x = width * height;

   774 		do {

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

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

   777 	}

   778 	else {

   779 		register int y;

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

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

   782 			register int x;

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

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

   785 				register int i;

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

   787 					register int j;

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

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

   790 				}

   791 			}

   792 		}

   793 	}

   794 	return unpacked;

   795 }

   796 

   797 static PyObject *

   798 gl_gversion(PyObject *self, PyObject *args)

   799 {

   800 	char buf[20];

   801 	gversion(buf);

   802 	return PyString_FromString(buf);

   803 }

   804 

   805 

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

   807 static PyObject *

   808 gl_clear(PyObject *self, PyObject *args)

   809 {

   810 	__GLclear( );

   811 	Py_INCREF(Py_None);

   812 	return Py_None;

   813 }

   814 

   815 /* End of manually written stubs */

   816 

   817 

   818 /* long getshade */

   819 

   820 static PyObject *

   821 gl_getshade(PyObject *self, PyObject *args)

   822 {

   823 	long retval;

   824 	retval = getshade( );

   825 	return mknewlongobject(retval);

   826 }

   827 

   828 /* void devport short s long s */

   829 

   830 static PyObject *

   831 gl_devport(PyObject *self, PyObject *args)

   832 {

   833 	short arg1 ;

   834 	long arg2 ;

   835 	if (!getishortarg(args, 2, 0, &arg1))

   836 		return NULL;

   837 	if (!getilongarg(args, 2, 1, &arg2))

   838 		return NULL;

   839 	devport( arg1 , arg2 );

   840 	Py_INCREF(Py_None);

   841 	return Py_None;

   842 }

   843 

   844 /* void rdr2i long s long s */

   845 

   846 static PyObject *

   847 gl_rdr2i(PyObject *self, PyObject *args)

   848 {

   849 	long arg1 ;

   850 	long arg2 ;

   851 	if (!getilongarg(args, 2, 0, &arg1))

   852 		return NULL;

   853 	if (!getilongarg(args, 2, 1, &arg2))

   854 		return NULL;

   855 	rdr2i( arg1 , arg2 );

   856 	Py_INCREF(Py_None);

   857 	return Py_None;

   858 }

   859 

   860 /* void rectfs short s short s short s short s */

   861 

   862 static PyObject *

   863 gl_rectfs(PyObject *self, PyObject *args)

   864 {

   865 	short arg1 ;

   866 	short arg2 ;

   867 	short arg3 ;

   868 	short arg4 ;

   869 	if (!getishortarg(args, 4, 0, &arg1))

   870 		return NULL;

   871 	if (!getishortarg(args, 4, 1, &arg2))

   872 		return NULL;

   873 	if (!getishortarg(args, 4, 2, &arg3))

   874 		return NULL;

   875 	if (!getishortarg(args, 4, 3, &arg4))

   876 		return NULL;

   877 	rectfs( arg1 , arg2 , arg3 , arg4 );

   878 	Py_INCREF(Py_None);

   879 	return Py_None;

   880 }

   881 

   882 /* void rects short s short s short s short s */

   883 

   884 static PyObject *

   885 gl_rects(PyObject *self, PyObject *args)

   886 {

   887 	short arg1 ;

   888 	short arg2 ;

   889 	short arg3 ;

   890 	short arg4 ;

   891 	if (!getishortarg(args, 4, 0, &arg1))

   892 		return NULL;

   893 	if (!getishortarg(args, 4, 1, &arg2))

   894 		return NULL;

   895 	if (!getishortarg(args, 4, 2, &arg3))

   896 		return NULL;

   897 	if (!getishortarg(args, 4, 3, &arg4))

   898 		return NULL;

   899 	rects( arg1 , arg2 , arg3 , arg4 );

   900 	Py_INCREF(Py_None);

   901 	return Py_None;

   902 }

   903 

   904 /* void rmv2i long s long s */

   905 

   906 static PyObject *

   907 gl_rmv2i(PyObject *self, PyObject *args)

   908 {

   909 	long arg1 ;

   910 	long arg2 ;

   911 	if (!getilongarg(args, 2, 0, &arg1))

   912 		return NULL;

   913 	if (!getilongarg(args, 2, 1, &arg2))

   914 		return NULL;

   915 	rmv2i( arg1 , arg2 );

   916 	Py_INCREF(Py_None);

   917 	return Py_None;

   918 }

   919 

   920 /* void noport */

   921 

   922 static PyObject *

   923 gl_noport(PyObject *self, PyObject *args)

   924 {

   925 	noport( );

   926 	Py_INCREF(Py_None);

   927 	return Py_None;

   928 }

   929 

   930 /* void popviewport */

   931 

   932 static PyObject *

   933 gl_popviewport(PyObject *self, PyObject *args)

   934 {

   935 	popviewport( );

   936 	Py_INCREF(Py_None);

   937 	return Py_None;

   938 }

   939 

   940 /* void clearhitcode */

   941 

   942 static PyObject *

   943 gl_clearhitcode(PyObject *self, PyObject *args)

   944 {

   945 	clearhitcode( );

   946 	Py_INCREF(Py_None);

   947 	return Py_None;

   948 }

   949 

   950 /* void closeobj */

   951 

   952 static PyObject *

   953 gl_closeobj(PyObject *self, PyObject *args)

   954 {

   955 	closeobj( );

   956 	Py_INCREF(Py_None);

   957 	return Py_None;

   958 }

   959 

   960 /* void cursoff */

   961 

   962 static PyObject *

   963 gl_cursoff(PyObject *self, PyObject *args)

   964 {

   965 	cursoff( );

   966 	Py_INCREF(Py_None);

   967 	return Py_None;

   968 }

   969 

   970 /* void curson */

   971 

   972 static PyObject *

   973 gl_curson(PyObject *self, PyObject *args)

   974 {

   975 	curson( );

   976 	Py_INCREF(Py_None);

   977 	return Py_None;

   978 }

   979 

   980 /* void doublebuffer */

   981 

   982 static PyObject *

   983 gl_doublebuffer(PyObject *self, PyObject *args)

   984 {

   985 	doublebuffer( );

   986 	Py_INCREF(Py_None);

   987 	return Py_None;

   988 }

   989 

   990 /* void finish */

   991 

   992 static PyObject *

   993 gl_finish(PyObject *self, PyObject *args)

   994 {

   995 	finish( );

   996 	Py_INCREF(Py_None);

   997 	return Py_None;

   998 }

   999 

  1000 /* void gconfig */

  1001 

  1002 static PyObject *

  1003 gl_gconfig(PyObject *self, PyObject *args)

  1004 {

  1005 	gconfig( );

  1006 	Py_INCREF(Py_None);

  1007 	return Py_None;

  1008 }

  1009 

  1010 /* void ginit */

  1011 

  1012 static PyObject *

  1013 gl_ginit(PyObject *self, PyObject *args)

  1014 {

  1015 	ginit( );

  1016 	Py_INCREF(Py_None);

  1017 	return Py_None;

  1018 }

  1019 

  1020 /* void greset */

  1021 

  1022 static PyObject *

  1023 gl_greset(PyObject *self, PyObject *args)

  1024 {

  1025 	greset( );

  1026 	Py_INCREF(Py_None);

  1027 	return Py_None;

  1028 }

  1029 

  1030 /* void multimap */

  1031 

  1032 static PyObject *

  1033 gl_multimap(PyObject *self, PyObject *args)

  1034 {

  1035 	multimap( );

  1036 	Py_INCREF(Py_None);

  1037 	return Py_None;

  1038 }

  1039 

  1040 /* void onemap */

  1041 

  1042 static PyObject *

  1043 gl_onemap(PyObject *self, PyObject *args)

  1044 {

  1045 	onemap( );

  1046 	Py_INCREF(Py_None);

  1047 	return Py_None;

  1048 }

  1049 

  1050 /* void popattributes */

  1051 

  1052 static PyObject *

  1053 gl_popattributes(PyObject *self, PyObject *args)

  1054 {

  1055 	popattributes( );

  1056 	Py_INCREF(Py_None);

  1057 	return Py_None;

  1058 }

  1059 

  1060 /* void popmatrix */

  1061 

  1062 static PyObject *

  1063 gl_popmatrix(PyObject *self, PyObject *args)

  1064 {

  1065 	popmatrix( );

  1066 	Py_INCREF(Py_None);

  1067 	return Py_None;

  1068 }

  1069 

  1070 /* void pushattributes */

  1071 

  1072 static PyObject *

  1073 gl_pushattributes(PyObject *self, PyObject *args)

  1074 {

  1075 	pushattributes( );

  1076 	Py_INCREF(Py_None);

  1077 	return Py_None;

  1078 }

  1079 

  1080 /* void pushmatrix */

  1081 

  1082 static PyObject *

  1083 gl_pushmatrix(PyObject *self, PyObject *args)

  1084 {

  1085 	pushmatrix( );

  1086 	Py_INCREF(Py_None);

  1087 	return Py_None;

  1088 }

  1089 

  1090 /* void pushviewport */

  1091 

  1092 static PyObject *

  1093 gl_pushviewport(PyObject *self, PyObject *args)

  1094 {

  1095 	pushviewport( );

  1096 	Py_INCREF(Py_None);

  1097 	return Py_None;

  1098 }

  1099 

  1100 /* void qreset */

  1101 

  1102 static PyObject *

  1103 gl_qreset(PyObject *self, PyObject *args)

  1104 {

  1105 	qreset( );

  1106 	Py_INCREF(Py_None);

  1107 	return Py_None;

  1108 }

  1109 

  1110 /* void RGBmode */

  1111 

  1112 static PyObject *

  1113 gl_RGBmode(PyObject *self, PyObject *args)

  1114 {

  1115 	RGBmode( );

  1116 	Py_INCREF(Py_None);

  1117 	return Py_None;

  1118 }

  1119 

  1120 /* void singlebuffer */

  1121 

  1122 static PyObject *

  1123 gl_singlebuffer(PyObject *self, PyObject *args)

  1124 {

  1125 	singlebuffer( );

  1126 	Py_INCREF(Py_None);

  1127 	return Py_None;

  1128 }

  1129 

  1130 /* void swapbuffers */

  1131 

  1132 static PyObject *

  1133 gl_swapbuffers(PyObject *self, PyObject *args)

  1134 {

  1135 	swapbuffers( );