extern PyObject *GrafObj_New(GrafPtr);
extern int GrafObj_Convert(PyObject *, GrafPtr *);
+extern PyObject *BMObj_New(BitMapPtr);
+extern int BMObj_Convert(PyObject *, BitMapPtr *);
+
extern PyObject *WinObj_WhichWindow(WindowPtr);
#include <QuickDraw.h>
{
if ( strcmp(name, "device") == 0 )
return PyInt_FromLong((long)self->ob_itself->device);
+ if ( strcmp(name, "portBits") == 0 )
+ return BMObj_New(&self->ob_itself->portBits);
if ( strcmp(name, "portRect") == 0 )
return Py_BuildValue("O&", PyMac_BuildRect, &self->ob_itself->portRect);
/* XXXX Add more, as needed */
/* -------------------- End object type GrafPort -------------------- */
+/* ----------------------- Object type BitMap ----------------------- */
+
+PyTypeObject BitMap_Type;
+
+#define BMObj_Check(x) ((x)->ob_type == &BitMap_Type)
+
+typedef struct BitMapObject {
+ PyObject_HEAD
+ BitMapPtr ob_itself;
+ PyObject *referred_object;
+ BitMap *referred_bitmap;
+} BitMapObject;
+
+PyObject *BMObj_New(itself)
+ BitMapPtr itself;
+{
+ BitMapObject *it;
+ if (itself == NULL) return PyMac_Error(resNotFound);
+ it = PyObject_NEW(BitMapObject, &BitMap_Type);
+ if (it == NULL) return NULL;
+ it->ob_itself = itself;
+ it->referred_object = NULL;
+ it->referred_bitmap = NULL;
+ return (PyObject *)it;
+}
+BMObj_Convert(v, p_itself)
+ PyObject *v;
+ BitMapPtr *p_itself;
+{
+ if (!BMObj_Check(v))
+ {
+ PyErr_SetString(PyExc_TypeError, "BitMap required");
+ return 0;
+ }
+ *p_itself = ((BitMapObject *)v)->ob_itself;
+ return 1;
+}
+
+static void BMObj_dealloc(self)
+ BitMapObject *self;
+{
+ Py_XDECREF(self->referred_object);
+ if (self->referred_bitmap) free(self->referred_bitmap);
+ PyMem_DEL(self);
+}
+
+static PyMethodDef BMObj_methods[] = {
+ {NULL, NULL, 0}
+};
+
+PyMethodChain BMObj_chain = { BMObj_methods, NULL };
+
+static PyObject *BMObj_getattr(self, name)
+ BitMapObject *self;
+ char *name;
+{
+ 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 */
+
+ return Py_FindMethodInChain(&BMObj_chain, (PyObject *)self, name);
+}
+
+#define BMObj_setattr NULL
+
+PyTypeObject BitMap_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /*ob_size*/
+ "BitMap", /*tp_name*/
+ sizeof(BitMapObject), /*tp_basicsize*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ (destructor) BMObj_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ (getattrfunc) BMObj_getattr, /*tp_getattr*/
+ (setattrfunc) BMObj_setattr, /*tp_setattr*/
+};
+
+/* --------------------- End object type BitMap --------------------- */
+
+
static PyObject *Qd_SetPort(_self, _args)
PyObject *_self;
PyObject *_args;
return _res;
}
+static PyObject *Qd_SetPortBits(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ BitMapPtr bm;
+ if (!PyArg_ParseTuple(_args, "O&",
+ BMObj_Convert, &bm))
+ return NULL;
+ SetPortBits(bm);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *Qd_PortSize(_self, _args)
PyObject *_self;
PyObject *_args;
return _res;
}
+static PyObject *Qd_BitMapToRegion(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ RgnHandle region;
+ BitMapPtr bMap;
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ ResObj_Convert, ®ion,
+ BMObj_Convert, &bMap))
+ return NULL;
+ _err = BitMapToRegion(region,
+ bMap);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *Qd_DisposeRgn(_self, _args)
PyObject *_self;
PyObject *_args;
return _res;
}
+static PyObject *Qd_CopyBits(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ BitMapPtr srcBits;
+ BitMapPtr dstBits;
+ Rect srcRect;
+ Rect dstRect;
+ short mode;
+ RgnHandle maskRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&hO&",
+ BMObj_Convert, &srcBits,
+ BMObj_Convert, &dstBits,
+ PyMac_GetRect, &srcRect,
+ PyMac_GetRect, &dstRect,
+ &mode,
+ ResObj_Convert, &maskRgn))
+ return NULL;
+ CopyBits(srcBits,
+ dstBits,
+ &srcRect,
+ &dstRect,
+ mode,
+ maskRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Qd_CopyMask(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ BitMapPtr srcBits;
+ BitMapPtr maskBits;
+ BitMapPtr dstBits;
+ Rect srcRect;
+ Rect maskRect;
+ Rect dstRect;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&O&O&",
+ BMObj_Convert, &srcBits,
+ BMObj_Convert, &maskBits,
+ BMObj_Convert, &dstBits,
+ PyMac_GetRect, &srcRect,
+ PyMac_GetRect, &maskRect,
+ PyMac_GetRect, &dstRect))
+ return NULL;
+ CopyMask(srcBits,
+ maskBits,
+ dstBits,
+ &srcRect,
+ &maskRect,
+ &dstRect);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *Qd_OpenPicture(_self, _args)
PyObject *_self;
PyObject *_args;
return _res;
}
+static PyObject *Qd_StdBits(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ BitMapPtr srcBits;
+ Rect srcRect;
+ Rect dstRect;
+ short mode;
+ RgnHandle maskRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&O&hO&",
+ BMObj_Convert, &srcBits,
+ PyMac_GetRect, &srcRect,
+ PyMac_GetRect, &dstRect,
+ &mode,
+ ResObj_Convert, &maskRgn))
+ return NULL;
+ StdBits(srcBits,
+ &srcRect,
+ &dstRect,
+ mode,
+ maskRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *Qd_AddPt(_self, _args)
PyObject *_self;
PyObject *_args;
return _res;
}
+static PyObject *Qd_CopyDeepMask(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+ BitMapPtr srcBits;
+ BitMapPtr maskBits;
+ BitMapPtr dstBits;
+ Rect srcRect;
+ Rect maskRect;
+ Rect dstRect;
+ short mode;
+ RgnHandle maskRgn;
+ if (!PyArg_ParseTuple(_args, "O&O&O&O&O&O&hO&",
+ BMObj_Convert, &srcBits,
+ BMObj_Convert, &maskBits,
+ BMObj_Convert, &dstBits,
+ PyMac_GetRect, &srcRect,
+ PyMac_GetRect, &maskRect,
+ PyMac_GetRect, &dstRect,
+ &mode,
+ ResObj_Convert, &maskRgn))
+ return NULL;
+ CopyDeepMask(srcBits,
+ maskBits,
+ dstBits,
+ &srcRect,
+ &maskRect,
+ &dstRect,
+ mode,
+ maskRgn);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *Qd_GetPattern(_self, _args)
PyObject *_self;
PyObject *_args;
return _res;
}
+static PyObject *Qd_BitMap(_self, _args)
+ PyObject *_self;
+ PyObject *_args;
+{
+ PyObject *_res = NULL;
+
+ 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;
+
+}
+
static PyMethodDef Qd_methods[] = {
{"SetPort", (PyCFunction)Qd_SetPort, 1,
"(GrafPtr port) -> None"},
"() -> (GrafPtr port)"},
{"GrafDevice", (PyCFunction)Qd_GrafDevice, 1,
"(short device) -> None"},
+ {"SetPortBits", (PyCFunction)Qd_SetPortBits, 1,
+ "(BitMapPtr bm) -> None"},
{"PortSize", (PyCFunction)Qd_PortSize, 1,
"(short width, short height) -> None"},
{"MovePortTo", (PyCFunction)Qd_MovePortTo, 1,
"() -> None"},
{"CloseRgn", (PyCFunction)Qd_CloseRgn, 1,
"(RgnHandle dstRgn) -> None"},
+ {"BitMapToRegion", (PyCFunction)Qd_BitMapToRegion, 1,
+ "(RgnHandle region, BitMapPtr bMap) -> None"},
{"DisposeRgn", (PyCFunction)Qd_DisposeRgn, 1,
"(RgnHandle rgn) -> None"},
{"CopyRgn", (PyCFunction)Qd_CopyRgn, 1,
"(RgnHandle rgn) -> None"},
{"ScrollRect", (PyCFunction)Qd_ScrollRect, 1,
"(Rect r, short dh, short dv, RgnHandle updateRgn) -> None"},
+ {"CopyBits", (PyCFunction)Qd_CopyBits, 1,
+ "(BitMapPtr srcBits, BitMapPtr dstBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"},
+ {"CopyMask", (PyCFunction)Qd_CopyMask, 1,
+ "(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect) -> None"},
{"OpenPicture", (PyCFunction)Qd_OpenPicture, 1,
"(Rect picFrame) -> (PicHandle _rv)"},
{"PicComment", (PyCFunction)Qd_PicComment, 1,
"(RgnHandle rgn, Rect srcRect, Rect dstRect) -> None"},
{"MapPoly", (PyCFunction)Qd_MapPoly, 1,
"(PolyHandle poly, Rect srcRect, Rect dstRect) -> None"},
+ {"StdBits", (PyCFunction)Qd_StdBits, 1,
+ "(BitMapPtr srcBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"},
{"AddPt", (PyCFunction)Qd_AddPt, 1,
"(Point src, Point dst) -> (Point dst)"},
{"EqualPt", (PyCFunction)Qd_EqualPt, 1,
"(short index, Boolean reserve) -> None"},
{"QDError", (PyCFunction)Qd_QDError, 1,
"() -> (short _rv)"},
+ {"CopyDeepMask", (PyCFunction)Qd_CopyDeepMask, 1,
+ "(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"},
{"GetPattern", (PyCFunction)Qd_GetPattern, 1,
"(short patternID) -> (PatHandle _rv)"},
{"GetCursor", (PyCFunction)Qd_GetCursor, 1,
"(Buffer textBuf, short firstByte, short byteCount) -> (short _rv)"},
{"CharExtra", (PyCFunction)Qd_CharExtra, 1,
"(Fixed extra) -> None"},
+ {"BitMap", (PyCFunction)Qd_BitMap, 1,
+ "Take (string, int, Rect) argument and create BitMap"},
{NULL, NULL, 0}
};
)
functions.append(f)
+f = Function(void, 'SetPortBits',
+ (BitMap_ptr, 'bm', InMode),
+)
+functions.append(f)
+
f = Function(void, 'PortSize',
(short, 'width', InMode),
(short, 'height', InMode),
)
functions.append(f)
+f = Function(OSErr, 'BitMapToRegion',
+ (RgnHandle, 'region', InMode),
+ (BitMap_ptr, 'bMap', InMode),
+)
+functions.append(f)
+
f = Function(void, 'DisposeRgn',
(RgnHandle, 'rgn', InMode),
)
)
functions.append(f)
+f = Function(void, 'CopyBits',
+ (BitMap_ptr, 'srcBits', InMode),
+ (BitMap_ptr, 'dstBits', InMode),
+ (Rect_ptr, 'srcRect', InMode),
+ (Rect_ptr, 'dstRect', InMode),
+ (short, 'mode', InMode),
+ (RgnHandle, 'maskRgn', InMode),
+)
+functions.append(f)
+
+f = Function(void, 'CopyMask',
+ (BitMap_ptr, 'srcBits', InMode),
+ (BitMap_ptr, 'maskBits', InMode),
+ (BitMap_ptr, 'dstBits', InMode),
+ (Rect_ptr, 'srcRect', InMode),
+ (Rect_ptr, 'maskRect', InMode),
+ (Rect_ptr, 'dstRect', InMode),
+)
+functions.append(f)
+
f = Function(PicHandle, 'OpenPicture',
(Rect_ptr, 'picFrame', InMode),
)
)
functions.append(f)
+f = Function(void, 'StdBits',
+ (BitMap_ptr, 'srcBits', InMode),
+ (Rect_ptr, 'srcRect', InMode),
+ (Rect_ptr, 'dstRect', InMode),
+ (short, 'mode', InMode),
+ (RgnHandle, 'maskRgn', InMode),
+)
+functions.append(f)
+
f = Function(void, 'AddPt',
(Point, 'src', InMode),
(Point, 'dst', InOutMode),
)
functions.append(f)
+f = Function(void, 'CopyDeepMask',
+ (BitMap_ptr, 'srcBits', InMode),
+ (BitMap_ptr, 'maskBits', InMode),
+ (BitMap_ptr, 'dstBits', InMode),
+ (Rect_ptr, 'srcRect', InMode),
+ (Rect_ptr, 'maskRect', InMode),
+ (Rect_ptr, 'dstRect', InMode),
+ (short, 'mode', InMode),
+ (RgnHandle, 'maskRgn', InMode),
+)
+functions.append(f)
+
f = Function(PatHandle, 'GetPattern',
(short, 'patternID', InMode),
)
CursHandle = OpaqueByValueType("CursHandle", "ResObj")
CGrafPtr = OpaqueByValueType("CGrafPtr", "GrafObj")
GrafPtr = OpaqueByValueType("GrafPtr", "GrafObj")
+BitMap_ptr = OpaqueByValueType("BitMapPtr", "BMObj")
includestuff = includestuff + """
#include <%s>""" % MACHEADERFILE + """
def outputGetattrHook(self):
Output("""if ( strcmp(name, "device") == 0 )
return PyInt_FromLong((long)self->ob_itself->device);
+ if ( strcmp(name, "portBits") == 0 )
+ return BMObj_New(&self->ob_itself->portBits);
if ( strcmp(name, "portRect") == 0 )
return Py_BuildValue("O&", PyMac_BuildRect, &self->ob_itself->portRect);
/* XXXX Add more, as needed */
""")
+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 */
+ """)
+
# Create the generator groups and link them
module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff)
##r_object = Region_ObjectDefinition('Region', 'QdRgn', 'RgnHandle')
##module.addobject(po_object)
gr_object = MyGRObjectDefinition("GrafPort", "GrafObj", "GrafPtr")
module.addobject(gr_object)
+bm_object = MyBMObjectDefinition("BitMap", "BMObj", "BitMapPtr")
+module.addobject(bm_object)
# Create the generator classes used to populate the lists
##for f in r_methods: r_object.add(f)
##for f in po_methods: po_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)
+
# generate output (open the output file as late as possible)
SetOutputFileName(OUTPUTFILE)
module.generate()
projects / python / commitdiff