path: root/Mac/Modules/qd/qdsupport.py

# This script generates a Python interface for an Apple Macintosh Manager.
# It uses the "bgen" package to generate C code.
# The function specifications are generated by scanning the mamager's header file,
# using the "scantools" package (customized for this particular manager).

import string

# Declarations that change for each manager
MACHEADERFILE = 'QuickDraw.h'		# The Apple header file
MODNAME = 'Qd'				# The name of the module
OBJECTNAME = 'Graf'			# The basic name of the objects used here

# The following is *usually* unchanged but may still require tuning
MODPREFIX = MODNAME			# The prefix for module-wide routines
OBJECTTYPE = OBJECTNAME + 'Ptr'		# The C type used to represent them
OBJECTPREFIX = MODPREFIX + 'Obj'	# The prefix for object methods
INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner
EXTRAFILE = string.lower(MODPREFIX) + 'edit.py' # A similar file but hand-made
OUTPUTFILE = MODNAME + "module.c"	# The file generated by this program

from macsupport import *

# Create the type objects

class TextThingieClass(FixedInputBufferType):
	def getargsCheck(self, name):
		pass

TextThingie = TextThingieClass(None)

# These are temporary!
RgnHandle = OpaqueByValueType("RgnHandle", "ResObj")
OptRgnHandle = OpaqueByValueType("RgnHandle", "OptResObj")
PicHandle = OpaqueByValueType("PicHandle", "ResObj")
PolyHandle = OpaqueByValueType("PolyHandle", "ResObj")
PixMapHandle = OpaqueByValueType("PixMapHandle", "ResObj")
PixPatHandle = OpaqueByValueType("PixPatHandle", "ResObj")
PatHandle = OpaqueByValueType("PatHandle", "ResObj")
CursHandle = OpaqueByValueType("CursHandle", "ResObj")
CCrsrHandle = OpaqueByValueType("CCrsrHandle", "ResObj")
CIconHandle = OpaqueByValueType("CIconHandle", "ResObj")
CTabHandle = OpaqueByValueType("CTabHandle", "ResObj")
ITabHandle = OpaqueByValueType("ITabHandle", "ResObj")
GDHandle = OpaqueByValueType("GDHandle", "ResObj")
CGrafPtr = OpaqueByValueType("CGrafPtr", "GrafObj")
GrafPtr = OpaqueByValueType("GrafPtr", "GrafObj")
BitMap_ptr = OpaqueByValueType("BitMapPtr", "BMObj")
RGBColor = OpaqueType('RGBColor', 'QdRGB')
RGBColor_ptr = RGBColor
FontInfo = OpaqueType('FontInfo', 'QdFI')

Cursor_ptr = StructInputBufferType('Cursor')
Pattern = StructOutputBufferType('Pattern')
Pattern_ptr = StructInputBufferType('Pattern')
PenState = StructOutputBufferType('PenState')
PenState_ptr = StructInputBufferType('PenState')

includestuff = includestuff + """
#include <%s>""" % MACHEADERFILE + """

/*
** Parse/generate RGB records
*/
PyObject *QdRGB_New(itself)
	RGBColorPtr itself;
{

	return Py_BuildValue("lll", (long)itself->red, (long)itself->green, (long)itself->blue);
}

QdRGB_Convert(v, p_itself)
	PyObject *v;
	RGBColorPtr p_itself;
{
	long red, green, blue;
	
	if( !PyArg_ParseTuple(v, "lll", &red, &green, &blue) )
		return 0;
	p_itself->red = (unsigned short)red;
	p_itself->green = (unsigned short)green;
	p_itself->blue = (unsigned short)blue;
	return 1;
}

/*
** Generate FontInfo records
*/
static
PyObject *QdFI_New(itself)
	FontInfo *itself;
{

	return Py_BuildValue("hhhh", itself->ascent, itself->descent,
			itself->widMax, itself->leading);
}


"""

variablestuff = """
{
	PyObject *o;
 	
	o = QDGA_New();
	if (o == NULL || PyDict_SetItemString(d, "qd", o) != 0)
		Py_FatalError("can't initialize Qd.qd");
}
"""

## not yet...
##
##class Region_ObjectDefinition(GlobalObjectDefinition):
##	def outputCheckNewArg(self):
##		Output("if (itself == NULL) return PyMac_Error(resNotFound);")
##	def outputFreeIt(self, itselfname):
##		Output("DisposeRegion(%s);", itselfname)
##
##class Polygon_ObjectDefinition(GlobalObjectDefinition):
##	def outputCheckNewArg(self):
##		Output("if (itself == NULL) return PyMac_Error(resNotFound);")
##	def outputFreeIt(self, itselfname):
##		Output("KillPoly(%s);", itselfname)

class MyGRObjectDefinition(GlobalObjectDefinition):
	def outputCheckNewArg(self):
		Output("if (itself == NULL) return PyMac_Error(resNotFound);")
	def outputCheckConvertArg(self):
		OutLbrace("if (DlgObj_Check(v) || WinObj_Check(v))")
		Output("*p_itself = ((GrafPortObject *)v)->ob_itself;")
		Output("return 1;")
		OutRbrace()
	def outputGetattrHook(self):
		Output("#ifndef TARGET_API_MAC_CARBON")
		Output("""
		{	CGrafPtr itself_color = (CGrafPtr)self->ob_itself;
		
			if ( strcmp(name, "data") == 0 )
				return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(GrafPort));
				
			if ( (itself_color->portVersion&0xc000) == 0xc000 ) {
				/* Color-only attributes */
			
				if ( strcmp(name, "portBits") == 0 )
					/* XXXX Do we need HLock() stuff here?? */
					return BMObj_New((BitMapPtr)*itself_color->portPixMap);
				if ( strcmp(name, "grafVars") == 0 )
					return Py_BuildValue("O&", ResObj_New, (Handle)itself_color->visRgn);
				if ( strcmp(name, "chExtra") == 0 )
					return Py_BuildValue("h", itself_color->chExtra);
				if ( strcmp(name, "pnLocHFrac") == 0 )
					return Py_BuildValue("h", itself_color->pnLocHFrac);
				if ( strcmp(name, "bkPixPat") == 0 )
					return Py_BuildValue("O&", ResObj_New, (Handle)itself_color->bkPixPat);
				if ( strcmp(name, "rgbFgColor") == 0 )
					return Py_BuildValue("O&", QdRGB_New, &itself_color->rgbFgColor);
				if ( strcmp(name, "rgbBkColor") == 0 )
					return Py_BuildValue("O&", QdRGB_New, &itself_color->rgbBkColor);
				if ( strcmp(name, "pnPixPat") == 0 )
					return Py_BuildValue("O&", ResObj_New, (Handle)itself_color->pnPixPat);
				if ( strcmp(name, "fillPixPat") == 0 )
					return Py_BuildValue("O&", ResObj_New, (Handle)itself_color->fillPixPat);
			} else {
				/* Mono-only attributes */
				if ( strcmp(name, "portBits") == 0 )
					return BMObj_New(&self->ob_itself->portBits);
				if ( strcmp(name, "bkPat") == 0 )
					return Py_BuildValue("s#", (char *)&self->ob_itself->bkPat, sizeof(Pattern));
				if ( strcmp(name, "fillPat") == 0 )
					return Py_BuildValue("s#", (char *)&self->ob_itself->fillPat, sizeof(Pattern));
				if ( strcmp(name, "pnPat") == 0 )
					return Py_BuildValue("s#", (char *)&self->ob_itself->pnPat, sizeof(Pattern));
			}
			/*
			** Accessible for both color/mono windows.
			** portVersion is really color-only, but we put it here
			** for convenience
			*/
			if ( strcmp(name, "portVersion") == 0 )
				return Py_BuildValue("h", itself_color->portVersion);
			if ( strcmp(name, "device") == 0 )
				return PyInt_FromLong((long)self->ob_itself->device);
			if ( strcmp(name, "portRect") == 0 )
				return Py_BuildValue("O&", PyMac_BuildRect, &self->ob_itself->portRect);
			if ( strcmp(name, "visRgn") == 0 )
				return Py_BuildValue("O&", ResObj_New, (Handle)self->ob_itself->visRgn);
			if ( strcmp(name, "clipRgn") == 0 )
				return Py_BuildValue("O&", ResObj_New, (Handle)self->ob_itself->clipRgn);
			if ( strcmp(name, "pnLoc") == 0 )
				return Py_BuildValue("O&", PyMac_BuildPoint, self->ob_itself->pnLoc);
			if ( strcmp(name, "pnSize") == 0 )
				return Py_BuildValue("O&", PyMac_BuildPoint, self->ob_itself->pnSize);
			if ( strcmp(name, "pnMode") == 0 )
				return Py_BuildValue("h", self->ob_itself->pnMode);
			if ( strcmp(name, "pnVis") == 0 )
				return Py_BuildValue("h", self->ob_itself->pnVis);
			if ( strcmp(name, "txFont") == 0 )
				return Py_BuildValue("h", self->ob_itself->txFont);
			if ( strcmp(name, "txFace") == 0 )
				return Py_BuildValue("h", (short)self->ob_itself->txFace);
			if ( strcmp(name, "txMode") == 0 )
				return Py_BuildValue("h", self->ob_itself->txMode);
			if ( strcmp(name, "txSize") == 0 )
				return Py_BuildValue("h", self->ob_itself->txSize);
			if ( strcmp(name, "spExtra") == 0 )
				return Py_BuildValue("O&", PyMac_BuildFixed, self->ob_itself->spExtra);
			/* XXXX Add more, as needed */
			/* This one is so we can compare grafports: */
			if ( strcmp(name, "_id") == 0 )
				return Py_BuildValue("l", (long)self->ob_itself);
		}""")
		Output("#endif")

class MyBMObjectDefinition(GlobalObjectDefinition):
	def outputCheckNewArg(self):
		Output("if (itself == NULL) return PyMac_Error(resNotFound);")
	def outputStructMembers(self):
		# We need to more items: a pointer to privately allocated data
		# and a python object we're referring to.
		Output("%s ob_itself;", self.itselftype)
		Output("PyObject *referred_object;")
		Output("BitMap *referred_bitmap;")
	def outputInitStructMembers(self):
		Output("it->ob_itself = %sitself;", self.argref)
		Output("it->referred_object = NULL;")
		Output("it->referred_bitmap = NULL;")
	def outputCleanupStructMembers(self):
		Output("Py_XDECREF(self->referred_object);")
		Output("if (self->referred_bitmap) free(self->referred_bitmap);")
	def outputGetattrHook(self):
		Output("""if ( strcmp(name, "baseAddr") == 0 )
			return PyInt_FromLong((long)self->ob_itself->baseAddr);
		if ( strcmp(name, "rowBytes") == 0 )
			return PyInt_FromLong((long)self->ob_itself->rowBytes);
		if ( strcmp(name, "bounds") == 0 )
			return Py_BuildValue("O&", PyMac_BuildRect, &self->ob_itself->bounds);
		/* XXXX Add more, as needed */
		if ( strcmp(name, "bitmap_data") == 0 )
			return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(BitMap));
		if ( strcmp(name, "pixmap_data") == 0 )
			return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(PixMap));
		""")
		
# This object is instanciated once, and will access qd globals.
class QDGlobalsAccessObjectDefinition(ObjectDefinition):
	def outputStructMembers(self):
		pass
	def outputNew(self):
		Output()
		Output("%sPyObject *%s_New()", self.static, self.prefix)
		OutLbrace()
		Output("%s *it;", self.objecttype)
		Output("it = PyObject_NEW(%s, &%s);", self.objecttype, self.typename)
		Output("if (it == NULL) return NULL;")
		Output("return (PyObject *)it;")
		OutRbrace()
	def outputConvert(self):
		pass
	def outputCleanupStructMembers(self):
		pass

	def outputGetattrHook(self):
		Output("#ifndef TARGET_API_MAC_CARBON")
		Output("""
	if ( strcmp(name, "arrow") == 0 )
		return PyString_FromStringAndSize((char *)&qd.arrow, sizeof(qd.arrow));
	if ( strcmp(name, "black") == 0 ) 
		return PyString_FromStringAndSize((char *)&qd.black, sizeof(qd.black));
	if ( strcmp(name, "white") == 0 ) 
		return PyString_FromStringAndSize((char *)&qd.white, sizeof(qd.white));
	if ( strcmp(name, "gray") == 0 ) 
		return PyString_FromStringAndSize((char *)&qd.gray, sizeof(qd.gray));
	if ( strcmp(name, "ltGray") == 0 ) 
		return PyString_FromStringAndSize((char *)&qd.ltGray, sizeof(qd.ltGray));
	if ( strcmp(name, "dkGray") == 0 ) 
		return PyString_FromStringAndSize((char *)&qd.dkGray, sizeof(qd.dkGray));
	if ( strcmp(name, "screenBits") == 0 ) 
		return BMObj_New(&qd.screenBits);
	if ( strcmp(name, "thePort") == 0 ) 
		return GrafObj_New(qd.thePort);
	if ( strcmp(name, "randSeed") == 0 ) 
		return Py_BuildValue("l", &qd.randSeed);
		""")
		Output("#else")
		Output("""
	if ( strcmp(name, "arrow") == 0 ) {
		Cursor rv;
		GetQDGlobalsArrow(&rv);
		return PyString_FromStringAndSize((char *)&rv, sizeof(rv));
	}
	if ( strcmp(name, "black") == 0 ) {
		Pattern rv;
		GetQDGlobalsBlack(&rv);
		return PyString_FromStringAndSize((char *)&rv, sizeof(rv));
	}
	if ( strcmp(name, "white") == 0 )  {
		Pattern rv;
		GetQDGlobalsWhite(&rv);
		return PyString_FromStringAndSize((char *)&rv, sizeof(rv));
	}
	if ( strcmp(name, "gray") == 0 )  {
		Pattern rv;
		GetQDGlobalsGray(&rv);
		return PyString_FromStringAndSize((char *)&rv, sizeof(rv));
	}
	if ( strcmp(name, "ltGray") == 0 )  {
		Pattern rv;
		GetQDGlobalsLightGray(&rv);
		return PyString_FromStringAndSize((char *)&rv, sizeof(rv));
	}
	if ( strcmp(name, "dkGray") == 0 )  {
		Pattern rv;
		GetQDGlobalsDarkGray(&rv);
		return PyString_FromStringAndSize((char *)&rv, sizeof(rv));
	}
	if ( strcmp(name, "screenBits") == 0 ) {
		BitMap rv;
		GetQDGlobalsScreenBits(&rv);
		return BMObj_New(&rv);
	}
	if ( strcmp(name, "thePort") == 0 ) 
		return GrafObj_New(GetQDGlobalsThePort());
	if ( strcmp(name, "randSeed") == 0 ) 
		return Py_BuildValue("l", GetQDGlobalsRandomSeed());
		""")
		Output("#endif")

# Create the generator groups and link them
module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff, variablestuff)
##r_object = Region_ObjectDefinition('Region', 'QdRgn', 'RgnHandle')
##po_object = Polygon_ObjectDefinition('Polygon', 'QdPgn', 'PolyHandle')
##module.addobject(r_object)
##module.addobject(po_object)
gr_object = MyGRObjectDefinition("GrafPort", "GrafObj", "GrafPtr")
module.addobject(gr_object)
bm_object = MyBMObjectDefinition("BitMap", "BMObj", "BitMapPtr")
module.addobject(bm_object)
qd_object = QDGlobalsAccessObjectDefinition("QDGlobalsAccess", "QDGA", "XXXX")
module.addobject(qd_object)


# Create the generator classes used to populate the lists
Function = OSErrFunctionGenerator
Method = OSErrMethodGenerator

# Create and populate the lists
functions = []
methods = []
execfile(INPUTFILE)
execfile(EXTRAFILE)

# add the populated lists to the generator groups
# (in a different wordl the scan program would generate this)
for f in functions: module.add(f)
##for f in r_methods: r_object.add(f)
##for f in po_methods: po_object.add(f)

# Manual generator: get data out of a bitmap
getdata_body = """
int from, length;
char *cp;

if ( !PyArg_ParseTuple(_args, "ii", &from, &length) )
	return NULL;
cp = _self->ob_itself->baseAddr+from;
return PyString_FromStringAndSize(cp, length);
"""
f = ManualGenerator("getdata", getdata_body)
f.docstring = lambda: """(int start, int size) -> string. Return bytes from the bitmap"""
bm_object.add(f)

# Manual generator: store data in a bitmap
putdata_body = """
int from, length;
char *cp, *icp;

if ( !PyArg_ParseTuple(_args, "is#", &from, &icp, &length) )
	return NULL;
cp = _self->ob_itself->baseAddr+from;
memcpy(cp, icp, length);
Py_INCREF(Py_None);
return Py_None;
"""
f = ManualGenerator("putdata", putdata_body)
f.docstring = lambda: """(int start, string data). Store bytes into the bitmap"""
bm_object.add(f)

#
# We manually generate a routine to create a BitMap from python data.
#
BitMap_body = """
BitMap *ptr;
PyObject *source;
Rect bounds;
int rowbytes;
char *data;

if ( !PyArg_ParseTuple(_args, "O!iO&", &PyString_Type, &source, &rowbytes, PyMac_GetRect,
		&bounds) )
	return NULL;
data = PyString_AsString(source);
if ((ptr=(BitMap *)malloc(sizeof(BitMap))) == NULL )
	return PyErr_NoMemory();
ptr->baseAddr = (Ptr)data;
ptr->rowBytes = rowbytes;
ptr->bounds = bounds;
if ( (_res = BMObj_New(ptr)) == NULL ) {
	free(ptr);
	return NULL;
}
((BitMapObject *)_res)->referred_object = source;
Py_INCREF(source);
((BitMapObject *)_res)->referred_bitmap = ptr;
return _res;
"""
	
f = ManualGenerator("BitMap", BitMap_body)
f.docstring = lambda: """Take (string, int, Rect) argument and create BitMap"""
module.add(f)

#
# And again, for turning a correctly-formatted structure into the object
#
RawBitMap_body = """
BitMap *ptr;
PyObject *source;

if ( !PyArg_ParseTuple(_args, "O!", &PyString_Type, &source) )
	return NULL;
if ( PyString_Size(source) != sizeof(BitMap) && PyString_Size(source) != sizeof(PixMap) ) {
	PyErr_BadArgument();
	return NULL;
}
ptr = (BitMapPtr)PyString_AsString(source);
if ( (_res = BMObj_New(ptr)) == NULL ) {
	return NULL;
}
((BitMapObject *)_res)->referred_object = source;
Py_INCREF(source);
return _res;
"""
	
f = ManualGenerator("RawBitMap", RawBitMap_body)
f.docstring = lambda: """Take string BitMap and turn into BitMap object"""
module.add(f)

# generate output (open the output file as late as possible)
SetOutputFileName(OUTPUTFILE)
module.generate()
SetOutputFile() # Close it