diff -r ffa851df0825 -r 2fb8b9db1c86 symbian-qemu-0.9.1-12/python-2.6.1/Mac/Modules/qd/qdsupport.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symbian-qemu-0.9.1-12/python-2.6.1/Mac/Modules/qd/qdsupport.py	Fri Jul 31 15:01:17 2009 +0100
@@ -0,0 +1,377 @@
+# 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 = 'Qd'                        # 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):
+        Output("/* Fool compiler warnings */")
+        Output("%s__in_len__ = %s__in_len__;", name, name)
+
+    def declareSize(self, name):
+        Output("int %s__in_len__;", name)
+
+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")
+const_BitMap_ptr = OpaqueByValueType("const BitMap *", "BMObj")
+BitMap = OpaqueType("BitMap", "BMObj_NewCopied", "BUG")
+RGBColor = OpaqueType('RGBColor', 'QdRGB')
+RGBColor_ptr = RGBColor
+FontInfo = OpaqueType('FontInfo', 'QdFI')
+Component = OpaqueByValueType('Component', 'CmpObj')
+ComponentInstance = OpaqueByValueType('ComponentInstance', 'CmpInstObj')
+
+Cursor = StructOutputBufferType('Cursor')
+Cursor_ptr = StructInputBufferType('Cursor')
+Pattern = StructOutputBufferType('Pattern')
+Pattern_ptr = StructInputBufferType('Pattern')
+PenState = StructOutputBufferType('PenState')
+PenState_ptr = StructInputBufferType('PenState')
+TruncCode = Type("TruncCode", "h")
+
+includestuff = includestuff + """
+#include <Carbon/Carbon.h>
+
+#ifdef USE_TOOLBOX_OBJECT_GLUE
+extern PyObject *_GrafObj_New(GrafPtr);
+extern int _GrafObj_Convert(PyObject *, GrafPtr *);
+extern PyObject *_BMObj_New(BitMapPtr);
+extern int _BMObj_Convert(PyObject *, BitMapPtr *);
+extern PyObject *_QdRGB_New(RGBColorPtr);
+extern int _QdRGB_Convert(PyObject *, RGBColorPtr);
+
+#define GrafObj_New _GrafObj_New
+#define GrafObj_Convert _GrafObj_Convert
+#define BMObj_New _BMObj_New
+#define BMObj_Convert _BMObj_Convert
+#define QdRGB_New _QdRGB_New
+#define QdRGB_Convert _QdRGB_Convert
+#endif
+
+static PyObject *BMObj_NewCopied(BitMapPtr);
+
+/*
+** Parse/generate RGB records
+*/
+PyObject *QdRGB_New(RGBColorPtr itself)
+{
+
+        return Py_BuildValue("lll", (long)itself->red, (long)itself->green, (long)itself->blue);
+}
+
+int QdRGB_Convert(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(FontInfo *itself)
+{
+
+        return Py_BuildValue("hhhh", itself->ascent, itself->descent,
+                        itself->widMax, itself->leading);
+}
+"""
+
+finalstuff = finalstuff + """
+/* Like BMObj_New, but the original bitmap data structure is copied (and
+** released when the object is released)
+*/
+PyObject *BMObj_NewCopied(BitMapPtr itself)
+{
+        BitMapObject *it;
+        BitMapPtr itself_copy;
+
+        if ((itself_copy=(BitMapPtr)malloc(sizeof(BitMap))) == NULL)
+                return PyErr_NoMemory();
+        *itself_copy = *itself;
+        it = (BitMapObject *)BMObj_New(itself_copy);
+        it->referred_bitmap = itself_copy;
+        return (PyObject *)it;
+}
+
+"""
+
+variablestuff = ""
+
+initstuff = initstuff + """
+        PyMac_INIT_TOOLBOX_OBJECT_NEW(BitMapPtr, BMObj_New);
+        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(BitMapPtr, BMObj_Convert);
+        PyMac_INIT_TOOLBOX_OBJECT_NEW(GrafPtr, GrafObj_New);
+        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(GrafPtr, GrafObj_Convert);
+        PyMac_INIT_TOOLBOX_OBJECT_NEW(RGBColorPtr, QdRGB_New);
+        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(RGBColor, QdRGB_Convert);
+"""
+
+## 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(PEP253Mixin, GlobalObjectDefinition):
+    getsetlist = [
+            ('visRgn',
+            """RgnHandle h=NewRgn(); /* XXXX wrong dispose routine */
+            return Py_BuildValue("O&", ResObj_New, (Handle)GetPortVisibleRegion(self->ob_itself, h));
+            """,
+            None,
+            "Convenience attribute: return a copy of the visible region"
+            ), (
+            'clipRgn',
+            """RgnHandle h=NewRgn(); /* XXXX wrong dispose routine */
+            return Py_BuildValue("O&", ResObj_New, (Handle)GetPortClipRegion(self->ob_itself, h));
+            """,
+            None,
+            "Convenience attribute: return a copy of the clipping region"
+            )]
+    def outputCheckNewArg(self):
+        Output("if (itself == NULL) return PyMac_Error(resNotFound);")
+    def outputCheckConvertArg(self):
+        Output("#if 1")
+        OutLbrace()
+        Output("WindowRef win;")
+        OutLbrace("if (WinObj_Convert(v, &win) && v)")
+        Output("*p_itself = (GrafPtr)GetWindowPort(win);")
+        Output("return 1;")
+        OutRbrace()
+        Output("PyErr_Clear();")
+        OutRbrace()
+        Output("#else")
+        OutLbrace("if (DlgObj_Check(v))")
+        Output("DialogRef dlg = (DialogRef)((GrafPortObject *)v)->ob_itself;")
+        Output("*p_itself = (GrafPtr)GetWindowPort(GetDialogWindow(dlg));")
+        Output("return 1;")
+        OutRbrace()
+        OutLbrace("if (WinObj_Check(v))")
+        Output("WindowRef win = (WindowRef)((GrafPortObject *)v)->ob_itself;")
+        Output("*p_itself = (GrafPtr)GetWindowPort(win);")
+        Output("return 1;")
+        OutRbrace()
+        Output("#endif")
+
+class MyBMObjectDefinition(PEP253Mixin, GlobalObjectDefinition):
+    getsetlist = [
+    (
+    'baseAddr',
+    'return PyInt_FromLong((long)self->ob_itself->baseAddr);',
+    None,
+    None
+    ), (
+    'rowBytes',
+    'return PyInt_FromLong((long)self->ob_itself->rowBytes);',
+    None,
+    None
+    ), (
+    'bounds',
+    'return Py_BuildValue("O&", PyMac_BuildRect, &self->ob_itself->bounds);',
+    None,
+    None
+    ), (
+    'bitmap_data',
+    'return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(BitMap));',
+    None,
+    None
+    ), (
+    'pixmap_data',
+    'return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(PixMap));',
+    None,
+    None
+    )]
+    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);")
+
+# 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)
+
+
+# Create the generator classes used to populate the lists
+Function = OSErrWeakLinkFunctionGenerator
+Method = OSErrWeakLinkMethodGenerator
+
+# Create and populate the lists
+functions = []
+gr_methods = []
+bm_methods = []
+#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 gr_methods: gr_object.add(f)
+for f in bm_methods: bm_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;
+_res = PyString_FromStringAndSize(cp, length);
+return _res;
+"""
+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);
+_res = Py_None;
+return _res;
+"""
+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_Format(PyExc_TypeError,
+                "Argument size was %d, should be %d (sizeof BitMap) or %d (sizeof PixMap)",
+                PyString_Size(source), sizeof(BitMap), sizeof(PixMap));
+        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