/* =========================== Module _CF =========================== */

#include "Python.h"

#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 <CoreServices/CoreServices.h>

#include "pycfbridge.h"

#ifdef USE_TOOLBOX_OBJECT_GLUE

extern PyObject *_CFObj_New(CFTypeRef);

extern int _CFObj_Convert(PyObject *, CFTypeRef *);

#define CFObj_New _CFObj_New

#define CFObj_Convert _CFObj_Convert

extern PyObject *_CFTypeRefObj_New(CFTypeRef);

extern int _CFTypeRefObj_Convert(PyObject *, CFTypeRef *);

#define CFTypeRefObj_New _CFTypeRefObj_New

#define CFTypeRefObj_Convert _CFTypeRefObj_Convert

extern PyObject *_CFStringRefObj_New(CFStringRef);

extern int _CFStringRefObj_Convert(PyObject *, CFStringRef *);

#define CFStringRefObj_New _CFStringRefObj_New

#define CFStringRefObj_Convert _CFStringRefObj_Convert

extern PyObject *_CFMutableStringRefObj_New(CFMutableStringRef);

extern int _CFMutableStringRefObj_Convert(PyObject *, CFMutableStringRef *);

#define CFMutableStringRefObj_New _CFMutableStringRefObj_New

#define CFMutableStringRefObj_Convert _CFMutableStringRefObj_Convert

extern PyObject *_CFArrayRefObj_New(CFArrayRef);

extern int _CFArrayRefObj_Convert(PyObject *, CFArrayRef *);

#define CFArrayRefObj_New _CFArrayRefObj_New

#define CFArrayRefObj_Convert _CFArrayRefObj_Convert

extern PyObject *_CFMutableArrayRefObj_New(CFMutableArrayRef);

extern int _CFMutableArrayRefObj_Convert(PyObject *, CFMutableArrayRef *);

#define CFMutableArrayRefObj_New _CFMutableArrayRefObj_New

#define CFMutableArrayRefObj_Convert _CFMutableArrayRefObj_Convert

extern PyObject *_CFDataRefObj_New(CFDataRef);

extern int _CFDataRefObj_Convert(PyObject *, CFDataRef *);

#define CFDataRefObj_New _CFDataRefObj_New

#define CFDataRefObj_Convert _CFDataRefObj_Convert

extern PyObject *_CFMutableDataRefObj_New(CFMutableDataRef);

extern int _CFMutableDataRefObj_Convert(PyObject *, CFMutableDataRef *);

#define CFMutableDataRefObj_New _CFMutableDataRefObj_New

#define CFMutableDataRefObj_Convert _CFMutableDataRefObj_Convert

extern PyObject *_CFDictionaryRefObj_New(CFDictionaryRef);

extern int _CFDictionaryRefObj_Convert(PyObject *, CFDictionaryRef *);

#define CFDictionaryRefObj_New _CFDictionaryRefObj_New

#define CFDictionaryRefObj_Convert _CFDictionaryRefObj_Convert

extern PyObject *_CFMutableDictionaryRefObj_New(CFMutableDictionaryRef);

extern int _CFMutableDictionaryRefObj_Convert(PyObject *, CFMutableDictionaryRef *);

#define CFMutableDictionaryRefObj_New _CFMutableDictionaryRefObj_New

#define CFMutableDictionaryRefObj_Convert _CFMutableDictionaryRefObj_Convert

extern PyObject *_CFURLRefObj_New(CFURLRef);

extern int _CFURLRefObj_Convert(PyObject *, CFURLRef *);

extern int _OptionalCFURLRefObj_Convert(PyObject *, CFURLRef *);

#define CFURLRefObj_New _CFURLRefObj_New

#define CFURLRefObj_Convert _CFURLRefObj_Convert

#define OptionalCFURLRefObj_Convert _OptionalCFURLRefObj_Convert

#endif

/*

** Parse/generate CFRange records

*/

PyObject *CFRange_New(CFRange *itself)

{

        return Py_BuildValue("ll", (long)itself->location, (long)itself->length);

}

int

CFRange_Convert(PyObject *v, CFRange *p_itself)

{

        long location, length;

        if( !PyArg_ParseTuple(v, "ll", &location, &length) )

                return 0;

        p_itself->location = (CFIndex)location;

        p_itself->length = (CFIndex)length;

        return 1;

}

/* Optional CFURL argument or None (passed as NULL) */

int

OptionalCFURLRefObj_Convert(PyObject *v, CFURLRef *p_itself)

{

    if ( v == Py_None ) {

        p_itself = NULL;

        return 1;

    }

    return CFURLRefObj_Convert(v, p_itself);

}

static PyObject *CF_Error;

/* --------------------- Object type CFTypeRef ---------------------- */

PyTypeObject CFTypeRef_Type;

#define CFTypeRefObj_Check(x) ((x)->ob_type == &CFTypeRef_Type || PyObject_TypeCheck((x), &CFTypeRef_Type))

typedef struct CFTypeRefObject {

	PyObject_HEAD

	CFTypeRef ob_itself;

	void (*ob_freeit)(CFTypeRef ptr);

} CFTypeRefObject;

PyObject *CFTypeRefObj_New(CFTypeRef itself)

{

	CFTypeRefObject *it;

	if (itself == NULL)

	{

		PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL");

		return NULL;

	}

	it = PyObject_NEW(CFTypeRefObject, &CFTypeRef_Type);

	if (it == NULL) return NULL;

	it->ob_itself = itself;

	it->ob_freeit = CFRelease;

	return (PyObject *)it;

}

int CFTypeRefObj_Convert(PyObject *v, CFTypeRef *p_itself)

{

	if (v == Py_None) { *p_itself = NULL; return 1; }

	/* Check for other CF objects here */

	if (!CFTypeRefObj_Check(v))

	{

		PyErr_SetString(PyExc_TypeError, "CFTypeRef required");

		return 0;

	}

	*p_itself = ((CFTypeRefObject *)v)->ob_itself;

	return 1;

}

static void CFTypeRefObj_dealloc(CFTypeRefObject *self)

{

	if (self->ob_freeit && self->ob_itself)

	{

		self->ob_freeit((CFTypeRef)self->ob_itself);

		self->ob_itself = NULL;

	}

	self->ob_type->tp_free((PyObject *)self);

}

static PyObject *CFTypeRefObj_CFGetTypeID(CFTypeRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	CFTypeID _rv;

#ifndef CFGetTypeID

	PyMac_PRECHECK(CFGetTypeID);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = CFGetTypeID(_self->ob_itself);

	_res = Py_BuildValue("l",

	                     _rv);

	return _res;

}

static PyObject *CFTypeRefObj_CFRetain(CFTypeRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	CFTypeRef _rv;

#ifndef CFRetain

	PyMac_PRECHECK(CFRetain);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = CFRetain(_self->ob_itself);

	_res = Py_BuildValue("O&",

	                     CFTypeRefObj_New, _rv);

	return _res;

}

static PyObject *CFTypeRefObj_CFRelease(CFTypeRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

#ifndef CFRelease

	PyMac_PRECHECK(CFRelease);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	CFRelease(_self->ob_itself);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CFTypeRefObj_CFGetRetainCount(CFTypeRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	CFIndex _rv;

#ifndef CFGetRetainCount

	PyMac_PRECHECK(CFGetRetainCount);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = CFGetRetainCount(_self->ob_itself);

	_res = Py_BuildValue("l",

	                     _rv);

	return _res;

}

static PyObject *CFTypeRefObj_CFEqual(CFTypeRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	Boolean _rv;

	CFTypeRef cf2;

#ifndef CFEqual

	PyMac_PRECHECK(CFEqual);

#endif

	if (!PyArg_ParseTuple(_args, "O&",

	                      CFTypeRefObj_Convert, &cf2))

		return NULL;

	_rv = CFEqual(_self->ob_itself,

	              cf2);

	_res = Py_BuildValue("l",

	                     _rv);

	return _res;

}

static PyObject *CFTypeRefObj_CFHash(CFTypeRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	CFHashCode _rv;

#ifndef CFHash

	PyMac_PRECHECK(CFHash);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = CFHash(_self->ob_itself);

	_res = Py_BuildValue("l",

	                     _rv);

	return _res;

}

static PyObject *CFTypeRefObj_CFCopyDescription(CFTypeRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	CFStringRef _rv;

#ifndef CFCopyDescription

	PyMac_PRECHECK(CFCopyDescription);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = CFCopyDescription(_self->ob_itself);

	_res = Py_BuildValue("O&",

	                     CFStringRefObj_New, _rv);

	return _res;

}

static PyObject *CFTypeRefObj_CFPropertyListCreateXMLData(CFTypeRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	CFDataRef _rv;

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	_rv = CFPropertyListCreateXMLData((CFAllocatorRef)NULL,

	                                  _self->ob_itself);

	_res = Py_BuildValue("O&",

	                     CFDataRefObj_New, _rv);

	return _res;

}

static PyObject *CFTypeRefObj_CFPropertyListCreateDeepCopy(CFTypeRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	CFTypeRef _rv;

	CFOptionFlags mutabilityOption;

	if (!PyArg_ParseTuple(_args, "l",

	                      &mutabilityOption))

		return NULL;

	_rv = CFPropertyListCreateDeepCopy((CFAllocatorRef)NULL,

	                                   _self->ob_itself,

	                                   mutabilityOption);

	_res = Py_BuildValue("O&",

	                     CFTypeRefObj_New, _rv);

	return _res;

}

static PyObject *CFTypeRefObj_CFShow(CFTypeRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

#ifndef CFShow

	PyMac_PRECHECK(CFShow);

#endif

	if (!PyArg_ParseTuple(_args, ""))

		return NULL;

	CFShow(_self->ob_itself);

	Py_INCREF(Py_None);

	_res = Py_None;

	return _res;

}

static PyObject *CFTypeRefObj_CFPropertyListCreateFromXMLData(CFTypeRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	CFTypeRef _rv;

	CFOptionFlags mutabilityOption;

	CFStringRef errorString;

	if (!PyArg_ParseTuple(_args, "l",

	                      &mutabilityOption))

	        return NULL;

	_rv = CFPropertyListCreateFromXMLData((CFAllocatorRef)NULL,

	                                      _self->ob_itself,

	                                      mutabilityOption,

	                                      &errorString);

	if (errorString)

	        CFRelease(errorString);

	if (_rv == NULL) {

	        PyErr_SetString(PyExc_RuntimeError, "Parse error in XML data");

	        return NULL;

	}

	_res = Py_BuildValue("O&",

	                     CFTypeRefObj_New, _rv);

	return _res;

}

static PyObject *CFTypeRefObj_toPython(CFTypeRefObject *_self, PyObject *_args)

{

	PyObject *_res = NULL;

	_res = PyCF_CF2Python(_self->ob_itself);

	return _res;

}

static PyMethodDef CFTypeRefObj_methods[] = {

	{"CFGetTypeID", (PyCFunction)CFTypeRefObj_CFGetTypeID, 1,

	 PyDoc_STR("() -> (CFTypeID _rv)")},

	{"CFRetain", (PyCFunction)CFTypeRefObj_CFRetain, 1,

	 PyDoc_STR("() -> (CFTypeRef _rv)")},

	{"CFRelease", (PyCFunction)CFTypeRefObj_CFRelease, 1,

	 PyDoc_STR("() -> None")},

	{"CFGetRetainCount", (PyCFunction)CFTypeRefObj_CFGetRetainCount, 1,

	 PyDoc_STR("() -> (CFIndex _rv)")},

	{"CFEqual", (PyCFunction)CFTypeRefObj_CFEqual, 1,

	 PyDoc_STR("(CFTypeRef cf2) -> (Boolean _rv)")},

	{"CFHash", (PyCFunction)CFTypeRefObj_CFHash, 1,

	 PyDoc_STR("() -> (CFHashCode _rv)")},

	{"CFCopyDescription", (PyCFunction)CFTypeRefObj_CFCopyDescription, 1,

	 PyDoc_STR("() -> (CFStringRef _rv)")},

	{"CFPropertyListCreateXMLData", (PyCFunction)CFTypeRefObj_CFPropertyListCreateXMLData, 1,

	 PyDoc_STR("() -> (CFDataRef _rv)")},

	{"CFPropertyListCreateDeepCopy", (PyCFunction)CFTypeRefObj_CFPropertyListCreateDeepCopy, 1,

	 PyDoc_STR("(CFOptionFlags mutabilityOption) -> (CFTypeRef _rv)")},

	{"CFShow", (PyCFunction)CFTypeRefObj_CFShow, 1,

	 PyDoc_STR("() -> None")},

	{"CFPropertyListCreateFromXMLData", (PyCFunction)CFTypeRefObj_CFPropertyListCreateFromXMLData, 1,

	 PyDoc_STR("(CFOptionFlags mutabilityOption) -> (CFTypeRefObj)")},

	{"toPython", (PyCFunction)CFTypeRefObj_toPython, 1,

	 PyDoc_STR("() -> (python_object)")},

	{NULL, NULL, 0}

};

#define CFTypeRefObj_getsetlist NULL

static int CFTypeRefObj_compare(CFTypeRefObject *self, CFTypeRefObject *other)

{

	/* XXXX Or should we use CFEqual?? */

	if ( self->ob_itself > other->ob_itself ) return 1;

	if ( self->ob_itself < other->ob_itself ) return -1;

	return 0;

}

static PyObject * CFTypeRefObj_repr(CFTypeRefObject *self)

{

	char buf[100];

	sprintf(buf, "<CFTypeRef type-%d object at 0x%8.8x for 0x%8.8x>", (int)CFGetTypeID(self->ob_itself), (unsigned)self, (unsigned)self->ob_itself);

	return PyString_FromString(buf);

}

static int CFTypeRefObj_hash(CFTypeRefObject *self)

{

	/* XXXX Or should we use CFHash?? */

	return (int)self->ob_itself;

}

static int CFTypeRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)

{

	CFTypeRef itself;

	char *kw[] = {"itself", 0};

	if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself))

	{

		((CFTypeRefObject *)_self)->ob_itself = itself;

		return 0;

	}

	return -1;

}

#define CFTypeRefObj_tp_alloc PyType_GenericAlloc

static PyObject *CFTypeRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)

{

	PyObject *self;

	if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;

	((CFTypeRefObject *)self)->ob_itself = NULL;

	((CFTypeRefObject *)self)->ob_freeit = CFRelease;

	return self;

}

#define CFTypeRefObj_tp_free PyObject_Del

PyTypeObject CFTypeRef_Type = {

	PyObject_HEAD_INIT(NULL)

	0, /*ob_size*/

	"_CF.CFTypeRef", /*tp_name*/

	sizeof(CFTypeRefObject), /*tp_basicsize*/

	0, /*tp_itemsize*/

	/* methods */

	(destructor) CFTypeRefObj_dealloc, /*tp_dealloc*/

	0, /*tp_print*/

	(getattrfunc)0, /*tp_getattr*/

	(setattrfunc)0, /*tp_setattr*/

	(cmpfunc) CFTypeRefObj_compare, /*tp_compare*/

	(reprfunc) CFTypeRefObj_repr, /*tp_repr*/

	(PyNumberMethods *)0, /* tp_as_number */

	(PySequenceMethods *)0, /* tp_as_sequence */

	(PyMappingMethods *)0, /* tp_as_mapping */

	(hashfunc) CFTypeRefObj_hash, /*tp_hash*/

	0, /*tp_call*/

	0, /*tp_str*/

	PyObject_GenericGetAttr, /*tp_getattro*/

	PyObject_GenericSetAttr, /*tp_setattro */

	0, /*tp_as_buffer*/

	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */

	0, /*tp_doc*/

	0, /*tp_traverse*/

	0, /*tp_clear*/

	0, /*tp_richcompare*/

	0, /*tp_weaklistoffset*/

	0, /*tp_iter*/

	0, /*tp_iternext*/

	CFTypeRefObj_methods, /* tp_methods */

	0, /*tp_members*/

	CFTypeRefObj_getsetlist, /*tp_getset*/

	0, /*tp_base*/

	0, /*tp_dict*/

	0, /*tp_descr_get*/

	0, /*tp_descr_set*/

	0, /*tp_dictoffset*/

	CFTypeRefObj_tp_init, /* tp_init */

	CFTypeRefObj_tp_alloc, /* tp_alloc */

	CFTypeRefObj_tp_new, /* tp_new */

	CFTypeRefObj_tp_free, /* tp_free */

};

/* ------------------- End object type CFTypeRef -------------------- */

/* --------------------- Object type CFArrayRef --------------------- */

PyTypeObject CFArrayRef_Type;

#define CFArrayRefObj_Check(x) ((x)->ob_type == &CFArrayRef_Type || PyObject_TypeCheck((x), &CFArrayRef_Type))

typedef struct CFArrayRefObject {

	PyObject_HEAD

	CFArrayRef ob_itself;

	void (*ob_freeit)(CFTypeRef ptr);

} CFArrayRefObject;

PyObject *CFArrayRefObj_New(CFArrayRef itself)

{

	CFArrayRefObject *it;

	if (itself == NULL)

	{

		PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL");

		return NULL;

	}

	it = PyObject_NEW(CFArrayRefObject, &CFArrayRef_Type);

	if (it == NULL) return NULL;

	/* XXXX Should we tp_init or tp_new our basetype? */

	it->ob_itself = itself;

	it->ob_freeit = CFRelease;

	return (PyObject *)it;

}

int CFArrayRefObj_Convert(PyObject *v, CFArrayRef *p_itself)

{

	if (v == Py_None) { *p_itself = NULL; return 1; }

	/* Check for other CF objects here */

	if (!CFArrayRefObj_Check(v))

	{

		PyErr_SetString(PyExc_TypeError, "CFArrayRef required");

		return 0;

	}

	*p_itself = ((CFArrayRefObject *)v)->ob_itself;

	return 1;

}

static void CFArrayRefObj_dealloc(CFArrayRefObject *self)

{

	if (self->ob_freeit && self->ob_itself)

	{

		self->ob_freeit((CFTypeRef)self->ob_itself);

		self->ob_itself = NULL;

	}

	CFTypeRef_Type.tp_dealloc((PyObject *)self);

}