diff -r ffa851df0825 -r 2fb8b9db1c86 symbian-qemu-0.9.1-12/python-2.6.1/Mac/Modules/scrap/_Scrapmodule.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symbian-qemu-0.9.1-12/python-2.6.1/Mac/Modules/scrap/_Scrapmodule.c	Fri Jul 31 15:01:17 2009 +0100
@@ -0,0 +1,365 @@
+
+/* ========================= Module _Scrap ========================== */
+
+#include "Python.h"
+
+
+#ifndef __LP64__
+
+#include "pymactoolbox.h"
+
+/* Macro to test whether a weak-loaded CFM function exists */
+#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
+        PyErr_SetString(PyExc_NotImplementedError, \
+        "Not available in this shared library/OS version"); \
+        return NULL; \
+    }} while(0)
+
+
+#include <Carbon/Carbon.h>
+
+static PyObject *Scrap_Error;
+
+/* ----------------------- Object type Scrap ------------------------ */
+
+PyTypeObject Scrap_Type;
+
+#define ScrapObj_Check(x) ((x)->ob_type == &Scrap_Type || PyObject_TypeCheck((x), &Scrap_Type))
+
+typedef struct ScrapObject {
+	PyObject_HEAD
+	ScrapRef ob_itself;
+} ScrapObject;
+
+PyObject *ScrapObj_New(ScrapRef itself)
+{
+	ScrapObject *it;
+	it = PyObject_NEW(ScrapObject, &Scrap_Type);
+	if (it == NULL) return NULL;
+	it->ob_itself = itself;
+	return (PyObject *)it;
+}
+int ScrapObj_Convert(PyObject *v, ScrapRef *p_itself)
+{
+	if (!ScrapObj_Check(v))
+	{
+		PyErr_SetString(PyExc_TypeError, "Scrap required");
+		return 0;
+	}
+	*p_itself = ((ScrapObject *)v)->ob_itself;
+	return 1;
+}
+
+static void ScrapObj_dealloc(ScrapObject *self)
+{
+	/* Cleanup of self->ob_itself goes here */
+	self->ob_type->tp_free((PyObject *)self);
+}
+
+static PyObject *ScrapObj_GetScrapFlavorFlags(ScrapObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	ScrapFlavorType flavorType;
+	ScrapFlavorFlags flavorFlags;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetOSType, &flavorType))
+		return NULL;
+	_err = GetScrapFlavorFlags(_self->ob_itself,
+	                           flavorType,
+	                           &flavorFlags);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     flavorFlags);
+	return _res;
+}
+
+static PyObject *ScrapObj_GetScrapFlavorSize(ScrapObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	ScrapFlavorType flavorType;
+	Size byteCount;
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetOSType, &flavorType))
+		return NULL;
+	_err = GetScrapFlavorSize(_self->ob_itself,
+	                          flavorType,
+	                          &byteCount);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     byteCount);
+	return _res;
+}
+
+static PyObject *ScrapObj_GetScrapFlavorData(ScrapObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	ScrapFlavorType flavorType;
+	Size byteCount;
+
+	if (!PyArg_ParseTuple(_args, "O&",
+	                      PyMac_GetOSType, &flavorType))
+		return NULL;
+	_err = GetScrapFlavorSize(_self->ob_itself,
+	                          flavorType,
+	                          &byteCount);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = PyString_FromStringAndSize(NULL, (int)byteCount);
+	if ( _res == NULL ) return NULL;
+	_err = GetScrapFlavorData(_self->ob_itself,
+	                          flavorType,
+	                          &byteCount,
+	                          PyString_AS_STRING(_res));
+	if (_err != noErr) {
+		Py_XDECREF(_res);
+		return PyMac_Error(_err);
+	}
+	return _res;
+}
+
+static PyObject *ScrapObj_PutScrapFlavor(ScrapObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	ScrapFlavorType flavorType;
+	ScrapFlavorFlags flavorFlags;
+	char *flavorData__in__;
+	int flavorData__in_len__;
+	if (!PyArg_ParseTuple(_args, "O&Ks#",
+	                      PyMac_GetOSType, &flavorType,
+	                      &flavorFlags,
+	                      &flavorData__in__, &flavorData__in_len__))
+		return NULL;
+	_err = PutScrapFlavor(_self->ob_itself,
+	                      flavorType,
+	                      flavorFlags,
+	                      (Size)flavorData__in_len__,
+	                      flavorData__in__);
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *ScrapObj_GetScrapFlavorCount(ScrapObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	UInt32 infoCount;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = GetScrapFlavorCount(_self->ob_itself,
+	                           &infoCount);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("l",
+	                     infoCount);
+	return _res;
+}
+
+static PyObject *ScrapObj_GetScrapFlavorInfoList(ScrapObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	PyObject *item;
+	OSStatus _err;
+	UInt32 infoCount;
+	ScrapFlavorInfo *infolist = NULL;
+	int i;
+	
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = GetScrapFlavorCount(_self->ob_itself,
+	                           &infoCount);
+	if (_err != noErr) return PyMac_Error(_err);
+	if (infoCount == 0) return Py_BuildValue("[]");
+	
+	if ((infolist = (ScrapFlavorInfo *)malloc(infoCount*sizeof(ScrapFlavorInfo))) == NULL )
+		return PyErr_NoMemory();
+	
+	_err = GetScrapFlavorInfoList(_self->ob_itself, &infoCount, infolist);
+	if (_err != noErr) {
+		free(infolist);
+		return NULL;
+	}
+	if ((_res = PyList_New(infoCount)) == NULL ) {
+		free(infolist);
+		return NULL;
+	}
+	for(i=0; i<infoCount; i++) {
+		item = Py_BuildValue("O&l", PyMac_BuildOSType, infolist[i].flavorType,
+			infolist[i].flavorFlags);
+		if ( !item || PyList_SetItem(_res, i, item) < 0 ) {
+			Py_DECREF(_res);
+			free(infolist);
+			return NULL;
+		}
+	}
+	free(infolist);
+	return _res;
+}
+
+static PyMethodDef ScrapObj_methods[] = {
+	{"GetScrapFlavorFlags", (PyCFunction)ScrapObj_GetScrapFlavorFlags, 1,
+	 PyDoc_STR("(ScrapFlavorType flavorType) -> (ScrapFlavorFlags flavorFlags)")},
+	{"GetScrapFlavorSize", (PyCFunction)ScrapObj_GetScrapFlavorSize, 1,
+	 PyDoc_STR("(ScrapFlavorType flavorType) -> (Size byteCount)")},
+	{"GetScrapFlavorData", (PyCFunction)ScrapObj_GetScrapFlavorData, 1,
+	 PyDoc_STR("(ScrapFlavorType flavorType, Buffer destination) -> (Size byteCount)")},
+	{"PutScrapFlavor", (PyCFunction)ScrapObj_PutScrapFlavor, 1,
+	 PyDoc_STR("(ScrapFlavorType flavorType, ScrapFlavorFlags flavorFlags, Size flavorSize, Buffer flavorData) -> None")},
+	{"GetScrapFlavorCount", (PyCFunction)ScrapObj_GetScrapFlavorCount, 1,
+	 PyDoc_STR("() -> (UInt32 infoCount)")},
+	{"GetScrapFlavorInfoList", (PyCFunction)ScrapObj_GetScrapFlavorInfoList, 1,
+	 PyDoc_STR("() -> ([(ScrapFlavorType, ScrapFlavorInfo), ...])")},
+	{NULL, NULL, 0}
+};
+
+PyMethodChain ScrapObj_chain = { ScrapObj_methods, NULL };
+
+static PyObject *ScrapObj_getattr(ScrapObject *self, char *name)
+{
+	return Py_FindMethodInChain(&ScrapObj_chain, (PyObject *)self, name);
+}
+
+#define ScrapObj_setattr NULL
+
+#define ScrapObj_compare NULL
+
+#define ScrapObj_repr NULL
+
+#define ScrapObj_hash NULL
+
+PyTypeObject Scrap_Type = {
+	PyObject_HEAD_INIT(NULL)
+	0, /*ob_size*/
+	"_Scrap.Scrap", /*tp_name*/
+	sizeof(ScrapObject), /*tp_basicsize*/
+	0, /*tp_itemsize*/
+	/* methods */
+	(destructor) ScrapObj_dealloc, /*tp_dealloc*/
+	0, /*tp_print*/
+	(getattrfunc) ScrapObj_getattr, /*tp_getattr*/
+	(setattrfunc) ScrapObj_setattr, /*tp_setattr*/
+	(cmpfunc) ScrapObj_compare, /*tp_compare*/
+	(reprfunc) ScrapObj_repr, /*tp_repr*/
+	(PyNumberMethods *)0, /* tp_as_number */
+	(PySequenceMethods *)0, /* tp_as_sequence */
+	(PyMappingMethods *)0, /* tp_as_mapping */
+	(hashfunc) ScrapObj_hash, /*tp_hash*/
+};
+
+/* --------------------- End object type Scrap ---------------------- */
+
+static PyObject *Scrap_LoadScrap(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = LoadScrap();
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Scrap_UnloadScrap(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = UnloadScrap();
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Scrap_GetCurrentScrap(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	ScrapRef scrap;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = GetCurrentScrap(&scrap);
+	if (_err != noErr) return PyMac_Error(_err);
+	_res = Py_BuildValue("O&",
+	                     ScrapObj_New, scrap);
+	return _res;
+}
+
+static PyObject *Scrap_ClearCurrentScrap(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = ClearCurrentScrap();
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+
+static PyObject *Scrap_CallInScrapPromises(PyObject *_self, PyObject *_args)
+{
+	PyObject *_res = NULL;
+	OSStatus _err;
+	if (!PyArg_ParseTuple(_args, ""))
+		return NULL;
+	_err = CallInScrapPromises();
+	if (_err != noErr) return PyMac_Error(_err);
+	Py_INCREF(Py_None);
+	_res = Py_None;
+	return _res;
+}
+#endif /* __LP64__ */
+
+static PyMethodDef Scrap_methods[] = {
+#ifndef __LP64__
+	{"LoadScrap", (PyCFunction)Scrap_LoadScrap, 1,
+	 PyDoc_STR("() -> None")},
+	{"UnloadScrap", (PyCFunction)Scrap_UnloadScrap, 1,
+	 PyDoc_STR("() -> None")},
+	{"GetCurrentScrap", (PyCFunction)Scrap_GetCurrentScrap, 1,
+	 PyDoc_STR("() -> (ScrapRef scrap)")},
+	{"ClearCurrentScrap", (PyCFunction)Scrap_ClearCurrentScrap, 1,
+	 PyDoc_STR("() -> None")},
+	{"CallInScrapPromises", (PyCFunction)Scrap_CallInScrapPromises, 1,
+	 PyDoc_STR("() -> None")},
+#endif /* __LP64__ */
+	{NULL, NULL, 0}
+};
+
+
+
+
+void init_Scrap(void)
+{
+	PyObject *m;
+#ifndef __LP64__
+	PyObject *d;
+#endif /* __LP64__ */
+
+
+
+
+	m = Py_InitModule("_Scrap", Scrap_methods);
+#ifndef __LP64__
+	d = PyModule_GetDict(m);
+	Scrap_Error = PyMac_GetOSErrException();
+	if (Scrap_Error == NULL ||
+	    PyDict_SetItemString(d, "Error", Scrap_Error) != 0)
+		return;
+	Scrap_Type.ob_type = &PyType_Type;
+	Py_INCREF(&Scrap_Type);
+	if (PyDict_SetItemString(d, "ScrapType", (PyObject *)&Scrap_Type) != 0)
+		Py_FatalError("can't initialize ScrapType");
+#endif /* __LP64__ */
+}
+
+/* ======================= End module _Scrap ======================== */
+