diff -r ffa851df0825 -r 2fb8b9db1c86 symbian-qemu-0.9.1-12/python-2.6.1/Mac/Modules/cf/_CFmodule.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/symbian-qemu-0.9.1-12/python-2.6.1/Mac/Modules/cf/_CFmodule.c Fri Jul 31 15:01:17 2009 +0100 @@ -0,0 +1,4996 @@ + +/* =========================== 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 + +#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, "", (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); +} + +static PyObject *CFArrayRefObj_CFArrayCreateCopy(CFArrayRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFArrayRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFArrayCreateCopy((CFAllocatorRef)NULL, + _self->ob_itself); + _res = Py_BuildValue("O&", + CFArrayRefObj_New, _rv); + return _res; +} + +static PyObject *CFArrayRefObj_CFArrayGetCount(CFArrayRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFIndex _rv; +#ifndef CFArrayGetCount + PyMac_PRECHECK(CFArrayGetCount); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFArrayGetCount(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CFArrayRefObj_CFStringCreateByCombiningStrings(CFArrayRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + CFStringRef separatorString; + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &separatorString)) + return NULL; + _rv = CFStringCreateByCombiningStrings((CFAllocatorRef)NULL, + _self->ob_itself, + separatorString); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyMethodDef CFArrayRefObj_methods[] = { + {"CFArrayCreateCopy", (PyCFunction)CFArrayRefObj_CFArrayCreateCopy, 1, + PyDoc_STR("() -> (CFArrayRef _rv)")}, + {"CFArrayGetCount", (PyCFunction)CFArrayRefObj_CFArrayGetCount, 1, + PyDoc_STR("() -> (CFIndex _rv)")}, + {"CFStringCreateByCombiningStrings", (PyCFunction)CFArrayRefObj_CFStringCreateByCombiningStrings, 1, + PyDoc_STR("(CFStringRef separatorString) -> (CFStringRef _rv)")}, + {NULL, NULL, 0} +}; + +#define CFArrayRefObj_getsetlist NULL + + +static int CFArrayRefObj_compare(CFArrayRefObject *self, CFArrayRefObject *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 * CFArrayRefObj_repr(CFArrayRefObject *self) +{ + char buf[100]; + sprintf(buf, "", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); +} + +static int CFArrayRefObj_hash(CFArrayRefObject *self) +{ + /* XXXX Or should we use CFHash?? */ + return (int)self->ob_itself; +} +static int CFArrayRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds) +{ + CFArrayRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFArrayRefObj_Convert, &itself)) + { + ((CFArrayRefObject *)_self)->ob_itself = itself; + return 0; + } + + /* Any CFTypeRef descendent is allowed as initializer too */ + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFArrayRefObject *)_self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFArrayRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFArrayRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFArrayRefObject *)self)->ob_itself = NULL; + ((CFArrayRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFArrayRefObj_tp_free PyObject_Del + + +PyTypeObject CFArrayRef_Type = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFArrayRef", /*tp_name*/ + sizeof(CFArrayRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFArrayRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ + (cmpfunc) CFArrayRefObj_compare, /*tp_compare*/ + (reprfunc) CFArrayRefObj_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) CFArrayRefObj_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*/ + CFArrayRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFArrayRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFArrayRefObj_tp_init, /* tp_init */ + CFArrayRefObj_tp_alloc, /* tp_alloc */ + CFArrayRefObj_tp_new, /* tp_new */ + CFArrayRefObj_tp_free, /* tp_free */ +}; + +/* ------------------- End object type CFArrayRef ------------------- */ + + +/* ----------------- Object type CFMutableArrayRef ------------------ */ + +PyTypeObject CFMutableArrayRef_Type; + +#define CFMutableArrayRefObj_Check(x) ((x)->ob_type == &CFMutableArrayRef_Type || PyObject_TypeCheck((x), &CFMutableArrayRef_Type)) + +typedef struct CFMutableArrayRefObject { + PyObject_HEAD + CFMutableArrayRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); +} CFMutableArrayRefObject; + +PyObject *CFMutableArrayRefObj_New(CFMutableArrayRef itself) +{ + CFMutableArrayRefObject *it; + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + it = PyObject_NEW(CFMutableArrayRefObject, &CFMutableArrayRef_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 CFMutableArrayRefObj_Convert(PyObject *v, CFMutableArrayRef *p_itself) +{ + + if (v == Py_None) { *p_itself = NULL; return 1; } + /* Check for other CF objects here */ + + if (!CFMutableArrayRefObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "CFMutableArrayRef required"); + return 0; + } + *p_itself = ((CFMutableArrayRefObject *)v)->ob_itself; + return 1; +} + +static void CFMutableArrayRefObj_dealloc(CFMutableArrayRefObject *self) +{ + if (self->ob_freeit && self->ob_itself) + { + self->ob_freeit((CFTypeRef)self->ob_itself); + self->ob_itself = NULL; + } + CFArrayRef_Type.tp_dealloc((PyObject *)self); +} + +static PyObject *CFMutableArrayRefObj_CFArrayRemoveValueAtIndex(CFMutableArrayRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFIndex idx; +#ifndef CFArrayRemoveValueAtIndex + PyMac_PRECHECK(CFArrayRemoveValueAtIndex); +#endif + if (!PyArg_ParseTuple(_args, "l", + &idx)) + return NULL; + CFArrayRemoveValueAtIndex(_self->ob_itself, + idx); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CFMutableArrayRefObj_CFArrayRemoveAllValues(CFMutableArrayRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; +#ifndef CFArrayRemoveAllValues + PyMac_PRECHECK(CFArrayRemoveAllValues); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + CFArrayRemoveAllValues(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CFMutableArrayRefObj_CFArrayExchangeValuesAtIndices(CFMutableArrayRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFIndex idx1; + CFIndex idx2; +#ifndef CFArrayExchangeValuesAtIndices + PyMac_PRECHECK(CFArrayExchangeValuesAtIndices); +#endif + if (!PyArg_ParseTuple(_args, "ll", + &idx1, + &idx2)) + return NULL; + CFArrayExchangeValuesAtIndices(_self->ob_itself, + idx1, + idx2); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CFMutableArrayRefObj_CFArrayAppendArray(CFMutableArrayRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFArrayRef otherArray; + CFRange otherRange; +#ifndef CFArrayAppendArray + PyMac_PRECHECK(CFArrayAppendArray); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CFArrayRefObj_Convert, &otherArray, + CFRange_Convert, &otherRange)) + return NULL; + CFArrayAppendArray(_self->ob_itself, + otherArray, + otherRange); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyMethodDef CFMutableArrayRefObj_methods[] = { + {"CFArrayRemoveValueAtIndex", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveValueAtIndex, 1, + PyDoc_STR("(CFIndex idx) -> None")}, + {"CFArrayRemoveAllValues", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveAllValues, 1, + PyDoc_STR("() -> None")}, + {"CFArrayExchangeValuesAtIndices", (PyCFunction)CFMutableArrayRefObj_CFArrayExchangeValuesAtIndices, 1, + PyDoc_STR("(CFIndex idx1, CFIndex idx2) -> None")}, + {"CFArrayAppendArray", (PyCFunction)CFMutableArrayRefObj_CFArrayAppendArray, 1, + PyDoc_STR("(CFArrayRef otherArray, CFRange otherRange) -> None")}, + {NULL, NULL, 0} +}; + +#define CFMutableArrayRefObj_getsetlist NULL + + +static int CFMutableArrayRefObj_compare(CFMutableArrayRefObject *self, CFMutableArrayRefObject *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 * CFMutableArrayRefObj_repr(CFMutableArrayRefObject *self) +{ + char buf[100]; + sprintf(buf, "", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); +} + +static int CFMutableArrayRefObj_hash(CFMutableArrayRefObject *self) +{ + /* XXXX Or should we use CFHash?? */ + return (int)self->ob_itself; +} +static int CFMutableArrayRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds) +{ + CFMutableArrayRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFMutableArrayRefObj_Convert, &itself)) + { + ((CFMutableArrayRefObject *)_self)->ob_itself = itself; + return 0; + } + + /* Any CFTypeRef descendent is allowed as initializer too */ + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFMutableArrayRefObject *)_self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFMutableArrayRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFMutableArrayRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFMutableArrayRefObject *)self)->ob_itself = NULL; + ((CFMutableArrayRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFMutableArrayRefObj_tp_free PyObject_Del + + +PyTypeObject CFMutableArrayRef_Type = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFMutableArrayRef", /*tp_name*/ + sizeof(CFMutableArrayRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFMutableArrayRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ + (cmpfunc) CFMutableArrayRefObj_compare, /*tp_compare*/ + (reprfunc) CFMutableArrayRefObj_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) CFMutableArrayRefObj_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*/ + CFMutableArrayRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFMutableArrayRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFMutableArrayRefObj_tp_init, /* tp_init */ + CFMutableArrayRefObj_tp_alloc, /* tp_alloc */ + CFMutableArrayRefObj_tp_new, /* tp_new */ + CFMutableArrayRefObj_tp_free, /* tp_free */ +}; + +/* --------------- End object type CFMutableArrayRef ---------------- */ + + +/* ------------------ Object type CFDictionaryRef ------------------- */ + +PyTypeObject CFDictionaryRef_Type; + +#define CFDictionaryRefObj_Check(x) ((x)->ob_type == &CFDictionaryRef_Type || PyObject_TypeCheck((x), &CFDictionaryRef_Type)) + +typedef struct CFDictionaryRefObject { + PyObject_HEAD + CFDictionaryRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); +} CFDictionaryRefObject; + +PyObject *CFDictionaryRefObj_New(CFDictionaryRef itself) +{ + CFDictionaryRefObject *it; + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + it = PyObject_NEW(CFDictionaryRefObject, &CFDictionaryRef_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 CFDictionaryRefObj_Convert(PyObject *v, CFDictionaryRef *p_itself) +{ + + if (v == Py_None) { *p_itself = NULL; return 1; } + /* Check for other CF objects here */ + + if (!CFDictionaryRefObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "CFDictionaryRef required"); + return 0; + } + *p_itself = ((CFDictionaryRefObject *)v)->ob_itself; + return 1; +} + +static void CFDictionaryRefObj_dealloc(CFDictionaryRefObject *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); +} + +static PyObject *CFDictionaryRefObj_CFDictionaryCreateCopy(CFDictionaryRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFDictionaryRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFDictionaryCreateCopy((CFAllocatorRef)NULL, + _self->ob_itself); + _res = Py_BuildValue("O&", + CFDictionaryRefObj_New, _rv); + return _res; +} + +static PyObject *CFDictionaryRefObj_CFDictionaryGetCount(CFDictionaryRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFIndex _rv; +#ifndef CFDictionaryGetCount + PyMac_PRECHECK(CFDictionaryGetCount); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFDictionaryGetCount(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyMethodDef CFDictionaryRefObj_methods[] = { + {"CFDictionaryCreateCopy", (PyCFunction)CFDictionaryRefObj_CFDictionaryCreateCopy, 1, + PyDoc_STR("() -> (CFDictionaryRef _rv)")}, + {"CFDictionaryGetCount", (PyCFunction)CFDictionaryRefObj_CFDictionaryGetCount, 1, + PyDoc_STR("() -> (CFIndex _rv)")}, + {NULL, NULL, 0} +}; + +#define CFDictionaryRefObj_getsetlist NULL + + +static int CFDictionaryRefObj_compare(CFDictionaryRefObject *self, CFDictionaryRefObject *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 * CFDictionaryRefObj_repr(CFDictionaryRefObject *self) +{ + char buf[100]; + sprintf(buf, "", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); +} + +static int CFDictionaryRefObj_hash(CFDictionaryRefObject *self) +{ + /* XXXX Or should we use CFHash?? */ + return (int)self->ob_itself; +} +static int CFDictionaryRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds) +{ + CFDictionaryRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFDictionaryRefObj_Convert, &itself)) + { + ((CFDictionaryRefObject *)_self)->ob_itself = itself; + return 0; + } + + /* Any CFTypeRef descendent is allowed as initializer too */ + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFDictionaryRefObject *)_self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFDictionaryRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFDictionaryRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFDictionaryRefObject *)self)->ob_itself = NULL; + ((CFDictionaryRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFDictionaryRefObj_tp_free PyObject_Del + + +PyTypeObject CFDictionaryRef_Type = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFDictionaryRef", /*tp_name*/ + sizeof(CFDictionaryRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFDictionaryRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ + (cmpfunc) CFDictionaryRefObj_compare, /*tp_compare*/ + (reprfunc) CFDictionaryRefObj_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) CFDictionaryRefObj_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*/ + CFDictionaryRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFDictionaryRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFDictionaryRefObj_tp_init, /* tp_init */ + CFDictionaryRefObj_tp_alloc, /* tp_alloc */ + CFDictionaryRefObj_tp_new, /* tp_new */ + CFDictionaryRefObj_tp_free, /* tp_free */ +}; + +/* ---------------- End object type CFDictionaryRef ----------------- */ + + +/* --------------- Object type CFMutableDictionaryRef --------------- */ + +PyTypeObject CFMutableDictionaryRef_Type; + +#define CFMutableDictionaryRefObj_Check(x) ((x)->ob_type == &CFMutableDictionaryRef_Type || PyObject_TypeCheck((x), &CFMutableDictionaryRef_Type)) + +typedef struct CFMutableDictionaryRefObject { + PyObject_HEAD + CFMutableDictionaryRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); +} CFMutableDictionaryRefObject; + +PyObject *CFMutableDictionaryRefObj_New(CFMutableDictionaryRef itself) +{ + CFMutableDictionaryRefObject *it; + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + it = PyObject_NEW(CFMutableDictionaryRefObject, &CFMutableDictionaryRef_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 CFMutableDictionaryRefObj_Convert(PyObject *v, CFMutableDictionaryRef *p_itself) +{ + + if (v == Py_None) { *p_itself = NULL; return 1; } + /* Check for other CF objects here */ + + if (!CFMutableDictionaryRefObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "CFMutableDictionaryRef required"); + return 0; + } + *p_itself = ((CFMutableDictionaryRefObject *)v)->ob_itself; + return 1; +} + +static void CFMutableDictionaryRefObj_dealloc(CFMutableDictionaryRefObject *self) +{ + if (self->ob_freeit && self->ob_itself) + { + self->ob_freeit((CFTypeRef)self->ob_itself); + self->ob_itself = NULL; + } + CFDictionaryRef_Type.tp_dealloc((PyObject *)self); +} + +static PyObject *CFMutableDictionaryRefObj_CFDictionaryRemoveAllValues(CFMutableDictionaryRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; +#ifndef CFDictionaryRemoveAllValues + PyMac_PRECHECK(CFDictionaryRemoveAllValues); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + CFDictionaryRemoveAllValues(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyMethodDef CFMutableDictionaryRefObj_methods[] = { + {"CFDictionaryRemoveAllValues", (PyCFunction)CFMutableDictionaryRefObj_CFDictionaryRemoveAllValues, 1, + PyDoc_STR("() -> None")}, + {NULL, NULL, 0} +}; + +#define CFMutableDictionaryRefObj_getsetlist NULL + + +static int CFMutableDictionaryRefObj_compare(CFMutableDictionaryRefObject *self, CFMutableDictionaryRefObject *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 * CFMutableDictionaryRefObj_repr(CFMutableDictionaryRefObject *self) +{ + char buf[100]; + sprintf(buf, "", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); +} + +static int CFMutableDictionaryRefObj_hash(CFMutableDictionaryRefObject *self) +{ + /* XXXX Or should we use CFHash?? */ + return (int)self->ob_itself; +} +static int CFMutableDictionaryRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds) +{ + CFMutableDictionaryRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFMutableDictionaryRefObj_Convert, &itself)) + { + ((CFMutableDictionaryRefObject *)_self)->ob_itself = itself; + return 0; + } + + /* Any CFTypeRef descendent is allowed as initializer too */ + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFMutableDictionaryRefObject *)_self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFMutableDictionaryRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFMutableDictionaryRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFMutableDictionaryRefObject *)self)->ob_itself = NULL; + ((CFMutableDictionaryRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFMutableDictionaryRefObj_tp_free PyObject_Del + + +PyTypeObject CFMutableDictionaryRef_Type = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFMutableDictionaryRef", /*tp_name*/ + sizeof(CFMutableDictionaryRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFMutableDictionaryRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ + (cmpfunc) CFMutableDictionaryRefObj_compare, /*tp_compare*/ + (reprfunc) CFMutableDictionaryRefObj_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) CFMutableDictionaryRefObj_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*/ + CFMutableDictionaryRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFMutableDictionaryRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFMutableDictionaryRefObj_tp_init, /* tp_init */ + CFMutableDictionaryRefObj_tp_alloc, /* tp_alloc */ + CFMutableDictionaryRefObj_tp_new, /* tp_new */ + CFMutableDictionaryRefObj_tp_free, /* tp_free */ +}; + +/* ------------- End object type CFMutableDictionaryRef ------------- */ + + +/* --------------------- Object type CFDataRef ---------------------- */ + +PyTypeObject CFDataRef_Type; + +#define CFDataRefObj_Check(x) ((x)->ob_type == &CFDataRef_Type || PyObject_TypeCheck((x), &CFDataRef_Type)) + +typedef struct CFDataRefObject { + PyObject_HEAD + CFDataRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); +} CFDataRefObject; + +PyObject *CFDataRefObj_New(CFDataRef itself) +{ + CFDataRefObject *it; + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + it = PyObject_NEW(CFDataRefObject, &CFDataRef_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 CFDataRefObj_Convert(PyObject *v, CFDataRef *p_itself) +{ + + if (v == Py_None) { *p_itself = NULL; return 1; } + if (PyString_Check(v)) { + char *cStr; + Py_ssize_t cLen; + if( PyString_AsStringAndSize(v, &cStr, &cLen) < 0 ) return 0; + *p_itself = CFDataCreate((CFAllocatorRef)NULL, (unsigned char *)cStr, cLen); + return 1; + } + + if (!CFDataRefObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "CFDataRef required"); + return 0; + } + *p_itself = ((CFDataRefObject *)v)->ob_itself; + return 1; +} + +static void CFDataRefObj_dealloc(CFDataRefObject *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); +} + +static PyObject *CFDataRefObj_CFDataCreateCopy(CFDataRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFDataRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFDataCreateCopy((CFAllocatorRef)NULL, + _self->ob_itself); + _res = Py_BuildValue("O&", + CFDataRefObj_New, _rv); + return _res; +} + +static PyObject *CFDataRefObj_CFDataGetLength(CFDataRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFIndex _rv; +#ifndef CFDataGetLength + PyMac_PRECHECK(CFDataGetLength); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFDataGetLength(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CFDataRefObj_CFStringCreateFromExternalRepresentation(CFDataRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + CFStringEncoding encoding; + if (!PyArg_ParseTuple(_args, "l", + &encoding)) + return NULL; + _rv = CFStringCreateFromExternalRepresentation((CFAllocatorRef)NULL, + _self->ob_itself, + encoding); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFDataRefObj_CFDataGetData(CFDataRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + + int size = CFDataGetLength(_self->ob_itself); + char *data = (char *)CFDataGetBytePtr(_self->ob_itself); + + _res = (PyObject *)PyString_FromStringAndSize(data, size); + return _res; + +} + +static PyMethodDef CFDataRefObj_methods[] = { + {"CFDataCreateCopy", (PyCFunction)CFDataRefObj_CFDataCreateCopy, 1, + PyDoc_STR("() -> (CFDataRef _rv)")}, + {"CFDataGetLength", (PyCFunction)CFDataRefObj_CFDataGetLength, 1, + PyDoc_STR("() -> (CFIndex _rv)")}, + {"CFStringCreateFromExternalRepresentation", (PyCFunction)CFDataRefObj_CFStringCreateFromExternalRepresentation, 1, + PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")}, + {"CFDataGetData", (PyCFunction)CFDataRefObj_CFDataGetData, 1, + PyDoc_STR("() -> (string _rv)")}, + {NULL, NULL, 0} +}; + +#define CFDataRefObj_getsetlist NULL + + +static int CFDataRefObj_compare(CFDataRefObject *self, CFDataRefObject *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 * CFDataRefObj_repr(CFDataRefObject *self) +{ + char buf[100]; + sprintf(buf, "", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); +} + +static int CFDataRefObj_hash(CFDataRefObject *self) +{ + /* XXXX Or should we use CFHash?? */ + return (int)self->ob_itself; +} +static int CFDataRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds) +{ + CFDataRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFDataRefObj_Convert, &itself)) + { + ((CFDataRefObject *)_self)->ob_itself = itself; + return 0; + } + + /* Any CFTypeRef descendent is allowed as initializer too */ + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFDataRefObject *)_self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFDataRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFDataRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFDataRefObject *)self)->ob_itself = NULL; + ((CFDataRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFDataRefObj_tp_free PyObject_Del + + +PyTypeObject CFDataRef_Type = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFDataRef", /*tp_name*/ + sizeof(CFDataRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFDataRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ + (cmpfunc) CFDataRefObj_compare, /*tp_compare*/ + (reprfunc) CFDataRefObj_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) CFDataRefObj_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*/ + CFDataRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFDataRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFDataRefObj_tp_init, /* tp_init */ + CFDataRefObj_tp_alloc, /* tp_alloc */ + CFDataRefObj_tp_new, /* tp_new */ + CFDataRefObj_tp_free, /* tp_free */ +}; + +/* ------------------- End object type CFDataRef -------------------- */ + + +/* ------------------ Object type CFMutableDataRef ------------------ */ + +PyTypeObject CFMutableDataRef_Type; + +#define CFMutableDataRefObj_Check(x) ((x)->ob_type == &CFMutableDataRef_Type || PyObject_TypeCheck((x), &CFMutableDataRef_Type)) + +typedef struct CFMutableDataRefObject { + PyObject_HEAD + CFMutableDataRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); +} CFMutableDataRefObject; + +PyObject *CFMutableDataRefObj_New(CFMutableDataRef itself) +{ + CFMutableDataRefObject *it; + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + it = PyObject_NEW(CFMutableDataRefObject, &CFMutableDataRef_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 CFMutableDataRefObj_Convert(PyObject *v, CFMutableDataRef *p_itself) +{ + + if (v == Py_None) { *p_itself = NULL; return 1; } + /* Check for other CF objects here */ + + if (!CFMutableDataRefObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "CFMutableDataRef required"); + return 0; + } + *p_itself = ((CFMutableDataRefObject *)v)->ob_itself; + return 1; +} + +static void CFMutableDataRefObj_dealloc(CFMutableDataRefObject *self) +{ + if (self->ob_freeit && self->ob_itself) + { + self->ob_freeit((CFTypeRef)self->ob_itself); + self->ob_itself = NULL; + } + CFDataRef_Type.tp_dealloc((PyObject *)self); +} + +static PyObject *CFMutableDataRefObj_CFDataSetLength(CFMutableDataRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFIndex length; +#ifndef CFDataSetLength + PyMac_PRECHECK(CFDataSetLength); +#endif + if (!PyArg_ParseTuple(_args, "l", + &length)) + return NULL; + CFDataSetLength(_self->ob_itself, + length); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CFMutableDataRefObj_CFDataIncreaseLength(CFMutableDataRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFIndex extraLength; +#ifndef CFDataIncreaseLength + PyMac_PRECHECK(CFDataIncreaseLength); +#endif + if (!PyArg_ParseTuple(_args, "l", + &extraLength)) + return NULL; + CFDataIncreaseLength(_self->ob_itself, + extraLength); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CFMutableDataRefObj_CFDataAppendBytes(CFMutableDataRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + unsigned char *bytes__in__; + long bytes__len__; + int bytes__in_len__; +#ifndef CFDataAppendBytes + PyMac_PRECHECK(CFDataAppendBytes); +#endif + if (!PyArg_ParseTuple(_args, "s#", + &bytes__in__, &bytes__in_len__)) + return NULL; + bytes__len__ = bytes__in_len__; + CFDataAppendBytes(_self->ob_itself, + bytes__in__, bytes__len__); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CFMutableDataRefObj_CFDataReplaceBytes(CFMutableDataRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFRange range; + unsigned char *newBytes__in__; + long newBytes__len__; + int newBytes__in_len__; +#ifndef CFDataReplaceBytes + PyMac_PRECHECK(CFDataReplaceBytes); +#endif + if (!PyArg_ParseTuple(_args, "O&s#", + CFRange_Convert, &range, + &newBytes__in__, &newBytes__in_len__)) + return NULL; + newBytes__len__ = newBytes__in_len__; + CFDataReplaceBytes(_self->ob_itself, + range, + newBytes__in__, newBytes__len__); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CFMutableDataRefObj_CFDataDeleteBytes(CFMutableDataRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFRange range; +#ifndef CFDataDeleteBytes + PyMac_PRECHECK(CFDataDeleteBytes); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CFRange_Convert, &range)) + return NULL; + CFDataDeleteBytes(_self->ob_itself, + range); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyMethodDef CFMutableDataRefObj_methods[] = { + {"CFDataSetLength", (PyCFunction)CFMutableDataRefObj_CFDataSetLength, 1, + PyDoc_STR("(CFIndex length) -> None")}, + {"CFDataIncreaseLength", (PyCFunction)CFMutableDataRefObj_CFDataIncreaseLength, 1, + PyDoc_STR("(CFIndex extraLength) -> None")}, + {"CFDataAppendBytes", (PyCFunction)CFMutableDataRefObj_CFDataAppendBytes, 1, + PyDoc_STR("(Buffer bytes) -> None")}, + {"CFDataReplaceBytes", (PyCFunction)CFMutableDataRefObj_CFDataReplaceBytes, 1, + PyDoc_STR("(CFRange range, Buffer newBytes) -> None")}, + {"CFDataDeleteBytes", (PyCFunction)CFMutableDataRefObj_CFDataDeleteBytes, 1, + PyDoc_STR("(CFRange range) -> None")}, + {NULL, NULL, 0} +}; + +#define CFMutableDataRefObj_getsetlist NULL + + +static int CFMutableDataRefObj_compare(CFMutableDataRefObject *self, CFMutableDataRefObject *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 * CFMutableDataRefObj_repr(CFMutableDataRefObject *self) +{ + char buf[100]; + sprintf(buf, "", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); +} + +static int CFMutableDataRefObj_hash(CFMutableDataRefObject *self) +{ + /* XXXX Or should we use CFHash?? */ + return (int)self->ob_itself; +} +static int CFMutableDataRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds) +{ + CFMutableDataRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFMutableDataRefObj_Convert, &itself)) + { + ((CFMutableDataRefObject *)_self)->ob_itself = itself; + return 0; + } + + /* Any CFTypeRef descendent is allowed as initializer too */ + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFMutableDataRefObject *)_self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFMutableDataRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFMutableDataRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFMutableDataRefObject *)self)->ob_itself = NULL; + ((CFMutableDataRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFMutableDataRefObj_tp_free PyObject_Del + + +PyTypeObject CFMutableDataRef_Type = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFMutableDataRef", /*tp_name*/ + sizeof(CFMutableDataRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFMutableDataRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ + (cmpfunc) CFMutableDataRefObj_compare, /*tp_compare*/ + (reprfunc) CFMutableDataRefObj_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) CFMutableDataRefObj_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*/ + CFMutableDataRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFMutableDataRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFMutableDataRefObj_tp_init, /* tp_init */ + CFMutableDataRefObj_tp_alloc, /* tp_alloc */ + CFMutableDataRefObj_tp_new, /* tp_new */ + CFMutableDataRefObj_tp_free, /* tp_free */ +}; + +/* ---------------- End object type CFMutableDataRef ---------------- */ + + +/* -------------------- Object type CFStringRef --------------------- */ + +PyTypeObject CFStringRef_Type; + +#define CFStringRefObj_Check(x) ((x)->ob_type == &CFStringRef_Type || PyObject_TypeCheck((x), &CFStringRef_Type)) + +typedef struct CFStringRefObject { + PyObject_HEAD + CFStringRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); +} CFStringRefObject; + +PyObject *CFStringRefObj_New(CFStringRef itself) +{ + CFStringRefObject *it; + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + it = PyObject_NEW(CFStringRefObject, &CFStringRef_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 CFStringRefObj_Convert(PyObject *v, CFStringRef *p_itself) +{ + + if (v == Py_None) { *p_itself = NULL; return 1; } + if (PyString_Check(v)) { + char *cStr; + if (!PyArg_Parse(v, "es", "ascii", &cStr)) + return 0; + *p_itself = CFStringCreateWithCString((CFAllocatorRef)NULL, cStr, kCFStringEncodingASCII); + PyMem_Free(cStr); + return 1; + } + if (PyUnicode_Check(v)) { + /* We use the CF types here, if Python was configured differently that will give an error */ + CFIndex size = PyUnicode_GetSize(v); + UniChar *unichars = PyUnicode_AsUnicode(v); + if (!unichars) return 0; + *p_itself = CFStringCreateWithCharacters((CFAllocatorRef)NULL, unichars, size); + return 1; + } + + + if (!CFStringRefObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "CFStringRef required"); + return 0; + } + *p_itself = ((CFStringRefObject *)v)->ob_itself; + return 1; +} + +static void CFStringRefObj_dealloc(CFStringRefObject *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); +} + +static PyObject *CFStringRefObj_CFStringCreateWithSubstring(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + CFRange range; + if (!PyArg_ParseTuple(_args, "O&", + CFRange_Convert, &range)) + return NULL; + _rv = CFStringCreateWithSubstring((CFAllocatorRef)NULL, + _self->ob_itself, + range); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFStringCreateCopy(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFStringCreateCopy((CFAllocatorRef)NULL, + _self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFStringGetLength(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFIndex _rv; +#ifndef CFStringGetLength + PyMac_PRECHECK(CFStringGetLength); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFStringGetLength(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFStringGetBytes(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFIndex _rv; + CFRange range; + CFStringEncoding encoding; + UInt8 lossByte; + Boolean isExternalRepresentation; + UInt8 buffer; + CFIndex maxBufLen; + CFIndex usedBufLen; +#ifndef CFStringGetBytes + PyMac_PRECHECK(CFStringGetBytes); +#endif + if (!PyArg_ParseTuple(_args, "O&lbll", + CFRange_Convert, &range, + &encoding, + &lossByte, + &isExternalRepresentation, + &maxBufLen)) + return NULL; + _rv = CFStringGetBytes(_self->ob_itself, + range, + encoding, + lossByte, + isExternalRepresentation, + &buffer, + maxBufLen, + &usedBufLen); + _res = Py_BuildValue("lbl", + _rv, + buffer, + usedBufLen); + return _res; +} + +static PyObject *CFStringRefObj_CFStringCreateExternalRepresentation(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFDataRef _rv; + CFStringEncoding encoding; + UInt8 lossByte; + if (!PyArg_ParseTuple(_args, "lb", + &encoding, + &lossByte)) + return NULL; + _rv = CFStringCreateExternalRepresentation((CFAllocatorRef)NULL, + _self->ob_itself, + encoding, + lossByte); + _res = Py_BuildValue("O&", + CFDataRefObj_New, _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFStringGetSmallestEncoding(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringEncoding _rv; +#ifndef CFStringGetSmallestEncoding + PyMac_PRECHECK(CFStringGetSmallestEncoding); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFStringGetSmallestEncoding(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFStringGetFastestEncoding(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringEncoding _rv; +#ifndef CFStringGetFastestEncoding + PyMac_PRECHECK(CFStringGetFastestEncoding); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFStringGetFastestEncoding(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFStringCompareWithOptions(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFComparisonResult _rv; + CFStringRef theString2; + CFRange rangeToCompare; + CFOptionFlags compareOptions; +#ifndef CFStringCompareWithOptions + PyMac_PRECHECK(CFStringCompareWithOptions); +#endif + if (!PyArg_ParseTuple(_args, "O&O&l", + CFStringRefObj_Convert, &theString2, + CFRange_Convert, &rangeToCompare, + &compareOptions)) + return NULL; + _rv = CFStringCompareWithOptions(_self->ob_itself, + theString2, + rangeToCompare, + compareOptions); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFStringCompare(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFComparisonResult _rv; + CFStringRef theString2; + CFOptionFlags compareOptions; +#ifndef CFStringCompare + PyMac_PRECHECK(CFStringCompare); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + CFStringRefObj_Convert, &theString2, + &compareOptions)) + return NULL; + _rv = CFStringCompare(_self->ob_itself, + theString2, + compareOptions); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFStringFindWithOptions(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + CFStringRef stringToFind; + CFRange rangeToSearch; + CFOptionFlags searchOptions; + CFRange result; +#ifndef CFStringFindWithOptions + PyMac_PRECHECK(CFStringFindWithOptions); +#endif + if (!PyArg_ParseTuple(_args, "O&O&l", + CFStringRefObj_Convert, &stringToFind, + CFRange_Convert, &rangeToSearch, + &searchOptions)) + return NULL; + _rv = CFStringFindWithOptions(_self->ob_itself, + stringToFind, + rangeToSearch, + searchOptions, + &result); + _res = Py_BuildValue("lO&", + _rv, + CFRange_New, result); + return _res; +} + +static PyObject *CFStringRefObj_CFStringCreateArrayWithFindResults(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFArrayRef _rv; + CFStringRef stringToFind; + CFRange rangeToSearch; + CFOptionFlags compareOptions; + if (!PyArg_ParseTuple(_args, "O&O&l", + CFStringRefObj_Convert, &stringToFind, + CFRange_Convert, &rangeToSearch, + &compareOptions)) + return NULL; + _rv = CFStringCreateArrayWithFindResults((CFAllocatorRef)NULL, + _self->ob_itself, + stringToFind, + rangeToSearch, + compareOptions); + _res = Py_BuildValue("O&", + CFArrayRefObj_New, _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFStringFind(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFRange _rv; + CFStringRef stringToFind; + CFOptionFlags compareOptions; +#ifndef CFStringFind + PyMac_PRECHECK(CFStringFind); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + CFStringRefObj_Convert, &stringToFind, + &compareOptions)) + return NULL; + _rv = CFStringFind(_self->ob_itself, + stringToFind, + compareOptions); + _res = Py_BuildValue("O&", + CFRange_New, _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFStringHasPrefix(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + CFStringRef prefix; +#ifndef CFStringHasPrefix + PyMac_PRECHECK(CFStringHasPrefix); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &prefix)) + return NULL; + _rv = CFStringHasPrefix(_self->ob_itself, + prefix); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFStringHasSuffix(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + CFStringRef suffix; +#ifndef CFStringHasSuffix + PyMac_PRECHECK(CFStringHasSuffix); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &suffix)) + return NULL; + _rv = CFStringHasSuffix(_self->ob_itself, + suffix); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFStringGetLineBounds(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFRange range; + CFIndex lineBeginIndex; + CFIndex lineEndIndex; + CFIndex contentsEndIndex; +#ifndef CFStringGetLineBounds + PyMac_PRECHECK(CFStringGetLineBounds); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CFRange_Convert, &range)) + return NULL; + CFStringGetLineBounds(_self->ob_itself, + range, + &lineBeginIndex, + &lineEndIndex, + &contentsEndIndex); + _res = Py_BuildValue("lll", + lineBeginIndex, + lineEndIndex, + contentsEndIndex); + return _res; +} + +static PyObject *CFStringRefObj_CFStringCreateArrayBySeparatingStrings(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFArrayRef _rv; + CFStringRef separatorString; + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &separatorString)) + return NULL; + _rv = CFStringCreateArrayBySeparatingStrings((CFAllocatorRef)NULL, + _self->ob_itself, + separatorString); + _res = Py_BuildValue("O&", + CFArrayRefObj_New, _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFStringGetIntValue(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + SInt32 _rv; +#ifndef CFStringGetIntValue + PyMac_PRECHECK(CFStringGetIntValue); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFStringGetIntValue(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFStringGetDoubleValue(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + double _rv; +#ifndef CFStringGetDoubleValue + PyMac_PRECHECK(CFStringGetDoubleValue); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFStringGetDoubleValue(_self->ob_itself); + _res = Py_BuildValue("d", + _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFStringConvertIANACharSetNameToEncoding(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringEncoding _rv; +#ifndef CFStringConvertIANACharSetNameToEncoding + PyMac_PRECHECK(CFStringConvertIANACharSetNameToEncoding); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFStringConvertIANACharSetNameToEncoding(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFShowStr(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; +#ifndef CFShowStr + PyMac_PRECHECK(CFShowStr); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + CFShowStr(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CFStringRefObj_CFURLCreateWithString(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFURLRef _rv; + CFURLRef baseURL; + if (!PyArg_ParseTuple(_args, "O&", + OptionalCFURLRefObj_Convert, &baseURL)) + return NULL; + _rv = CFURLCreateWithString((CFAllocatorRef)NULL, + _self->ob_itself, + baseURL); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFURLCreateWithFileSystemPath(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFURLRef _rv; + CFURLPathStyle pathStyle; + Boolean isDirectory; + if (!PyArg_ParseTuple(_args, "ll", + &pathStyle, + &isDirectory)) + return NULL; + _rv = CFURLCreateWithFileSystemPath((CFAllocatorRef)NULL, + _self->ob_itself, + pathStyle, + isDirectory); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFURLCreateWithFileSystemPathRelativeToBase(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFURLRef _rv; + CFURLPathStyle pathStyle; + Boolean isDirectory; + CFURLRef baseURL; + if (!PyArg_ParseTuple(_args, "llO&", + &pathStyle, + &isDirectory, + OptionalCFURLRefObj_Convert, &baseURL)) + return NULL; + _rv = CFURLCreateWithFileSystemPathRelativeToBase((CFAllocatorRef)NULL, + _self->ob_itself, + pathStyle, + isDirectory, + baseURL); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFURLCreateStringByReplacingPercentEscapes(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + CFStringRef charactersToLeaveEscaped; + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &charactersToLeaveEscaped)) + return NULL; + _rv = CFURLCreateStringByReplacingPercentEscapes((CFAllocatorRef)NULL, + _self->ob_itself, + charactersToLeaveEscaped); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFURLCreateStringByAddingPercentEscapes(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + CFStringRef charactersToLeaveUnescaped; + CFStringRef legalURLCharactersToBeEscaped; + CFStringEncoding encoding; + if (!PyArg_ParseTuple(_args, "O&O&l", + CFStringRefObj_Convert, &charactersToLeaveUnescaped, + CFStringRefObj_Convert, &legalURLCharactersToBeEscaped, + &encoding)) + return NULL; + _rv = CFURLCreateStringByAddingPercentEscapes((CFAllocatorRef)NULL, + _self->ob_itself, + charactersToLeaveUnescaped, + legalURLCharactersToBeEscaped, + encoding); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFStringRefObj_CFStringGetString(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + + int size = CFStringGetLength(_self->ob_itself)+1; + char *data = malloc(size); + + if( data == NULL ) return PyErr_NoMemory(); + if ( CFStringGetCString(_self->ob_itself, data, size, 0) ) { + _res = (PyObject *)PyString_FromString(data); + } else { + PyErr_SetString(PyExc_RuntimeError, "CFStringGetCString could not fit the string"); + _res = NULL; + } + free(data); + return _res; + +} + +static PyObject *CFStringRefObj_CFStringGetUnicode(CFStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + + int size = CFStringGetLength(_self->ob_itself)+1; + Py_UNICODE *data = malloc(size*sizeof(Py_UNICODE)); + CFRange range; + + range.location = 0; + range.length = size; + if( data == NULL ) return PyErr_NoMemory(); + CFStringGetCharacters(_self->ob_itself, range, data); + _res = (PyObject *)PyUnicode_FromUnicode(data, size-1); + free(data); + return _res; + +} + +static PyMethodDef CFStringRefObj_methods[] = { + {"CFStringCreateWithSubstring", (PyCFunction)CFStringRefObj_CFStringCreateWithSubstring, 1, + PyDoc_STR("(CFRange range) -> (CFStringRef _rv)")}, + {"CFStringCreateCopy", (PyCFunction)CFStringRefObj_CFStringCreateCopy, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFStringGetLength", (PyCFunction)CFStringRefObj_CFStringGetLength, 1, + PyDoc_STR("() -> (CFIndex _rv)")}, + {"CFStringGetBytes", (PyCFunction)CFStringRefObj_CFStringGetBytes, 1, + PyDoc_STR("(CFRange range, CFStringEncoding encoding, UInt8 lossByte, Boolean isExternalRepresentation, CFIndex maxBufLen) -> (CFIndex _rv, UInt8 buffer, CFIndex usedBufLen)")}, + {"CFStringCreateExternalRepresentation", (PyCFunction)CFStringRefObj_CFStringCreateExternalRepresentation, 1, + PyDoc_STR("(CFStringEncoding encoding, UInt8 lossByte) -> (CFDataRef _rv)")}, + {"CFStringGetSmallestEncoding", (PyCFunction)CFStringRefObj_CFStringGetSmallestEncoding, 1, + PyDoc_STR("() -> (CFStringEncoding _rv)")}, + {"CFStringGetFastestEncoding", (PyCFunction)CFStringRefObj_CFStringGetFastestEncoding, 1, + PyDoc_STR("() -> (CFStringEncoding _rv)")}, + {"CFStringCompareWithOptions", (PyCFunction)CFStringRefObj_CFStringCompareWithOptions, 1, + PyDoc_STR("(CFStringRef theString2, CFRange rangeToCompare, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)")}, + {"CFStringCompare", (PyCFunction)CFStringRefObj_CFStringCompare, 1, + PyDoc_STR("(CFStringRef theString2, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)")}, + {"CFStringFindWithOptions", (PyCFunction)CFStringRefObj_CFStringFindWithOptions, 1, + PyDoc_STR("(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags searchOptions) -> (Boolean _rv, CFRange result)")}, + {"CFStringCreateArrayWithFindResults", (PyCFunction)CFStringRefObj_CFStringCreateArrayWithFindResults, 1, + PyDoc_STR("(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags compareOptions) -> (CFArrayRef _rv)")}, + {"CFStringFind", (PyCFunction)CFStringRefObj_CFStringFind, 1, + PyDoc_STR("(CFStringRef stringToFind, CFOptionFlags compareOptions) -> (CFRange _rv)")}, + {"CFStringHasPrefix", (PyCFunction)CFStringRefObj_CFStringHasPrefix, 1, + PyDoc_STR("(CFStringRef prefix) -> (Boolean _rv)")}, + {"CFStringHasSuffix", (PyCFunction)CFStringRefObj_CFStringHasSuffix, 1, + PyDoc_STR("(CFStringRef suffix) -> (Boolean _rv)")}, + {"CFStringGetLineBounds", (PyCFunction)CFStringRefObj_CFStringGetLineBounds, 1, + PyDoc_STR("(CFRange range) -> (CFIndex lineBeginIndex, CFIndex lineEndIndex, CFIndex contentsEndIndex)")}, + {"CFStringCreateArrayBySeparatingStrings", (PyCFunction)CFStringRefObj_CFStringCreateArrayBySeparatingStrings, 1, + PyDoc_STR("(CFStringRef separatorString) -> (CFArrayRef _rv)")}, + {"CFStringGetIntValue", (PyCFunction)CFStringRefObj_CFStringGetIntValue, 1, + PyDoc_STR("() -> (SInt32 _rv)")}, + {"CFStringGetDoubleValue", (PyCFunction)CFStringRefObj_CFStringGetDoubleValue, 1, + PyDoc_STR("() -> (double _rv)")}, + {"CFStringConvertIANACharSetNameToEncoding", (PyCFunction)CFStringRefObj_CFStringConvertIANACharSetNameToEncoding, 1, + PyDoc_STR("() -> (CFStringEncoding _rv)")}, + {"CFShowStr", (PyCFunction)CFStringRefObj_CFShowStr, 1, + PyDoc_STR("() -> None")}, + {"CFURLCreateWithString", (PyCFunction)CFStringRefObj_CFURLCreateWithString, 1, + PyDoc_STR("(CFURLRef baseURL) -> (CFURLRef _rv)")}, + {"CFURLCreateWithFileSystemPath", (PyCFunction)CFStringRefObj_CFURLCreateWithFileSystemPath, 1, + PyDoc_STR("(CFURLPathStyle pathStyle, Boolean isDirectory) -> (CFURLRef _rv)")}, + {"CFURLCreateWithFileSystemPathRelativeToBase", (PyCFunction)CFStringRefObj_CFURLCreateWithFileSystemPathRelativeToBase, 1, + PyDoc_STR("(CFURLPathStyle pathStyle, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)")}, + {"CFURLCreateStringByReplacingPercentEscapes", (PyCFunction)CFStringRefObj_CFURLCreateStringByReplacingPercentEscapes, 1, + PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")}, + {"CFURLCreateStringByAddingPercentEscapes", (PyCFunction)CFStringRefObj_CFURLCreateStringByAddingPercentEscapes, 1, + PyDoc_STR("(CFStringRef charactersToLeaveUnescaped, CFStringRef legalURLCharactersToBeEscaped, CFStringEncoding encoding) -> (CFStringRef _rv)")}, + {"CFStringGetString", (PyCFunction)CFStringRefObj_CFStringGetString, 1, + PyDoc_STR("() -> (string _rv)")}, + {"CFStringGetUnicode", (PyCFunction)CFStringRefObj_CFStringGetUnicode, 1, + PyDoc_STR("() -> (unicode _rv)")}, + {NULL, NULL, 0} +}; + +#define CFStringRefObj_getsetlist NULL + + +static int CFStringRefObj_compare(CFStringRefObject *self, CFStringRefObject *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 * CFStringRefObj_repr(CFStringRefObject *self) +{ + char buf[100]; + sprintf(buf, "", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); +} + +static int CFStringRefObj_hash(CFStringRefObject *self) +{ + /* XXXX Or should we use CFHash?? */ + return (int)self->ob_itself; +} +static int CFStringRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds) +{ + CFStringRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFStringRefObj_Convert, &itself)) + { + ((CFStringRefObject *)_self)->ob_itself = itself; + return 0; + } + + /* Any CFTypeRef descendent is allowed as initializer too */ + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFStringRefObject *)_self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFStringRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFStringRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFStringRefObject *)self)->ob_itself = NULL; + ((CFStringRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFStringRefObj_tp_free PyObject_Del + + +PyTypeObject CFStringRef_Type = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFStringRef", /*tp_name*/ + sizeof(CFStringRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFStringRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ + (cmpfunc) CFStringRefObj_compare, /*tp_compare*/ + (reprfunc) CFStringRefObj_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) CFStringRefObj_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*/ + CFStringRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFStringRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFStringRefObj_tp_init, /* tp_init */ + CFStringRefObj_tp_alloc, /* tp_alloc */ + CFStringRefObj_tp_new, /* tp_new */ + CFStringRefObj_tp_free, /* tp_free */ +}; + +/* ------------------ End object type CFStringRef ------------------- */ + + +/* ----------------- Object type CFMutableStringRef ----------------- */ + +PyTypeObject CFMutableStringRef_Type; + +#define CFMutableStringRefObj_Check(x) ((x)->ob_type == &CFMutableStringRef_Type || PyObject_TypeCheck((x), &CFMutableStringRef_Type)) + +typedef struct CFMutableStringRefObject { + PyObject_HEAD + CFMutableStringRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); +} CFMutableStringRefObject; + +PyObject *CFMutableStringRefObj_New(CFMutableStringRef itself) +{ + CFMutableStringRefObject *it; + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + it = PyObject_NEW(CFMutableStringRefObject, &CFMutableStringRef_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 CFMutableStringRefObj_Convert(PyObject *v, CFMutableStringRef *p_itself) +{ + + if (v == Py_None) { *p_itself = NULL; return 1; } + /* Check for other CF objects here */ + + if (!CFMutableStringRefObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "CFMutableStringRef required"); + return 0; + } + *p_itself = ((CFMutableStringRefObject *)v)->ob_itself; + return 1; +} + +static void CFMutableStringRefObj_dealloc(CFMutableStringRefObject *self) +{ + if (self->ob_freeit && self->ob_itself) + { + self->ob_freeit((CFTypeRef)self->ob_itself); + self->ob_itself = NULL; + } + CFStringRef_Type.tp_dealloc((PyObject *)self); +} + +static PyObject *CFMutableStringRefObj_CFStringAppend(CFMutableStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef appendedString; +#ifndef CFStringAppend + PyMac_PRECHECK(CFStringAppend); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &appendedString)) + return NULL; + CFStringAppend(_self->ob_itself, + appendedString); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CFMutableStringRefObj_CFStringAppendCharacters(CFMutableStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + UniChar *chars__in__; + UniCharCount chars__len__; + int chars__in_len__; +#ifndef CFStringAppendCharacters + PyMac_PRECHECK(CFStringAppendCharacters); +#endif + if (!PyArg_ParseTuple(_args, "u#", + &chars__in__, &chars__in_len__)) + return NULL; + chars__len__ = chars__in_len__; + CFStringAppendCharacters(_self->ob_itself, + chars__in__, chars__len__); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CFMutableStringRefObj_CFStringAppendPascalString(CFMutableStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Str255 pStr; + CFStringEncoding encoding; +#ifndef CFStringAppendPascalString + PyMac_PRECHECK(CFStringAppendPascalString); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + PyMac_GetStr255, pStr, + &encoding)) + return NULL; + CFStringAppendPascalString(_self->ob_itself, + pStr, + encoding); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CFMutableStringRefObj_CFStringAppendCString(CFMutableStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + char* cStr; + CFStringEncoding encoding; +#ifndef CFStringAppendCString + PyMac_PRECHECK(CFStringAppendCString); +#endif + if (!PyArg_ParseTuple(_args, "sl", + &cStr, + &encoding)) + return NULL; + CFStringAppendCString(_self->ob_itself, + cStr, + encoding); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CFMutableStringRefObj_CFStringInsert(CFMutableStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFIndex idx; + CFStringRef insertedStr; +#ifndef CFStringInsert + PyMac_PRECHECK(CFStringInsert); +#endif + if (!PyArg_ParseTuple(_args, "lO&", + &idx, + CFStringRefObj_Convert, &insertedStr)) + return NULL; + CFStringInsert(_self->ob_itself, + idx, + insertedStr); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CFMutableStringRefObj_CFStringDelete(CFMutableStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFRange range; +#ifndef CFStringDelete + PyMac_PRECHECK(CFStringDelete); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CFRange_Convert, &range)) + return NULL; + CFStringDelete(_self->ob_itself, + range); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CFMutableStringRefObj_CFStringReplace(CFMutableStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFRange range; + CFStringRef replacement; +#ifndef CFStringReplace + PyMac_PRECHECK(CFStringReplace); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CFRange_Convert, &range, + CFStringRefObj_Convert, &replacement)) + return NULL; + CFStringReplace(_self->ob_itself, + range, + replacement); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CFMutableStringRefObj_CFStringReplaceAll(CFMutableStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef replacement; +#ifndef CFStringReplaceAll + PyMac_PRECHECK(CFStringReplaceAll); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &replacement)) + return NULL; + CFStringReplaceAll(_self->ob_itself, + replacement); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CFMutableStringRefObj_CFStringPad(CFMutableStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef padString; + CFIndex length; + CFIndex indexIntoPad; +#ifndef CFStringPad + PyMac_PRECHECK(CFStringPad); +#endif + if (!PyArg_ParseTuple(_args, "O&ll", + CFStringRefObj_Convert, &padString, + &length, + &indexIntoPad)) + return NULL; + CFStringPad(_self->ob_itself, + padString, + length, + indexIntoPad); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CFMutableStringRefObj_CFStringTrim(CFMutableStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef trimString; +#ifndef CFStringTrim + PyMac_PRECHECK(CFStringTrim); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &trimString)) + return NULL; + CFStringTrim(_self->ob_itself, + trimString); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CFMutableStringRefObj_CFStringTrimWhitespace(CFMutableStringRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; +#ifndef CFStringTrimWhitespace + PyMac_PRECHECK(CFStringTrimWhitespace); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + CFStringTrimWhitespace(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyMethodDef CFMutableStringRefObj_methods[] = { + {"CFStringAppend", (PyCFunction)CFMutableStringRefObj_CFStringAppend, 1, + PyDoc_STR("(CFStringRef appendedString) -> None")}, + {"CFStringAppendCharacters", (PyCFunction)CFMutableStringRefObj_CFStringAppendCharacters, 1, + PyDoc_STR("(Buffer chars) -> None")}, + {"CFStringAppendPascalString", (PyCFunction)CFMutableStringRefObj_CFStringAppendPascalString, 1, + PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> None")}, + {"CFStringAppendCString", (PyCFunction)CFMutableStringRefObj_CFStringAppendCString, 1, + PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> None")}, + {"CFStringInsert", (PyCFunction)CFMutableStringRefObj_CFStringInsert, 1, + PyDoc_STR("(CFIndex idx, CFStringRef insertedStr) -> None")}, + {"CFStringDelete", (PyCFunction)CFMutableStringRefObj_CFStringDelete, 1, + PyDoc_STR("(CFRange range) -> None")}, + {"CFStringReplace", (PyCFunction)CFMutableStringRefObj_CFStringReplace, 1, + PyDoc_STR("(CFRange range, CFStringRef replacement) -> None")}, + {"CFStringReplaceAll", (PyCFunction)CFMutableStringRefObj_CFStringReplaceAll, 1, + PyDoc_STR("(CFStringRef replacement) -> None")}, + {"CFStringPad", (PyCFunction)CFMutableStringRefObj_CFStringPad, 1, + PyDoc_STR("(CFStringRef padString, CFIndex length, CFIndex indexIntoPad) -> None")}, + {"CFStringTrim", (PyCFunction)CFMutableStringRefObj_CFStringTrim, 1, + PyDoc_STR("(CFStringRef trimString) -> None")}, + {"CFStringTrimWhitespace", (PyCFunction)CFMutableStringRefObj_CFStringTrimWhitespace, 1, + PyDoc_STR("() -> None")}, + {NULL, NULL, 0} +}; + +#define CFMutableStringRefObj_getsetlist NULL + + +static int CFMutableStringRefObj_compare(CFMutableStringRefObject *self, CFMutableStringRefObject *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 * CFMutableStringRefObj_repr(CFMutableStringRefObject *self) +{ + char buf[100]; + sprintf(buf, "", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); +} + +static int CFMutableStringRefObj_hash(CFMutableStringRefObject *self) +{ + /* XXXX Or should we use CFHash?? */ + return (int)self->ob_itself; +} +static int CFMutableStringRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds) +{ + CFMutableStringRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFMutableStringRefObj_Convert, &itself)) + { + ((CFMutableStringRefObject *)_self)->ob_itself = itself; + return 0; + } + + /* Any CFTypeRef descendent is allowed as initializer too */ + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFMutableStringRefObject *)_self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFMutableStringRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFMutableStringRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFMutableStringRefObject *)self)->ob_itself = NULL; + ((CFMutableStringRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFMutableStringRefObj_tp_free PyObject_Del + + +PyTypeObject CFMutableStringRef_Type = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFMutableStringRef", /*tp_name*/ + sizeof(CFMutableStringRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFMutableStringRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ + (cmpfunc) CFMutableStringRefObj_compare, /*tp_compare*/ + (reprfunc) CFMutableStringRefObj_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) CFMutableStringRefObj_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*/ + CFMutableStringRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFMutableStringRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFMutableStringRefObj_tp_init, /* tp_init */ + CFMutableStringRefObj_tp_alloc, /* tp_alloc */ + CFMutableStringRefObj_tp_new, /* tp_new */ + CFMutableStringRefObj_tp_free, /* tp_free */ +}; + +/* --------------- End object type CFMutableStringRef --------------- */ + + +/* ---------------------- Object type CFURLRef ---------------------- */ + +PyTypeObject CFURLRef_Type; + +#define CFURLRefObj_Check(x) ((x)->ob_type == &CFURLRef_Type || PyObject_TypeCheck((x), &CFURLRef_Type)) + +typedef struct CFURLRefObject { + PyObject_HEAD + CFURLRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); +} CFURLRefObject; + +PyObject *CFURLRefObj_New(CFURLRef itself) +{ + CFURLRefObject *it; + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + it = PyObject_NEW(CFURLRefObject, &CFURLRef_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 CFURLRefObj_Convert(PyObject *v, CFURLRef *p_itself) +{ + + if (v == Py_None) { *p_itself = NULL; return 1; } + /* Check for other CF objects here */ + + if (!CFURLRefObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "CFURLRef required"); + return 0; + } + *p_itself = ((CFURLRefObject *)v)->ob_itself; + return 1; +} + +static void CFURLRefObj_dealloc(CFURLRefObject *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); +} + +static PyObject *CFURLRefObj_CFURLCreateData(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFDataRef _rv; + CFStringEncoding encoding; + Boolean escapeWhitespace; + if (!PyArg_ParseTuple(_args, "ll", + &encoding, + &escapeWhitespace)) + return NULL; + _rv = CFURLCreateData((CFAllocatorRef)NULL, + _self->ob_itself, + encoding, + escapeWhitespace); + _res = Py_BuildValue("O&", + CFDataRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLGetFileSystemRepresentation(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + Boolean resolveAgainstBase; + UInt8 buffer; + CFIndex maxBufLen; +#ifndef CFURLGetFileSystemRepresentation + PyMac_PRECHECK(CFURLGetFileSystemRepresentation); +#endif + if (!PyArg_ParseTuple(_args, "ll", + &resolveAgainstBase, + &maxBufLen)) + return NULL; + _rv = CFURLGetFileSystemRepresentation(_self->ob_itself, + resolveAgainstBase, + &buffer, + maxBufLen); + _res = Py_BuildValue("lb", + _rv, + buffer); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCopyAbsoluteURL(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFURLRef _rv; +#ifndef CFURLCopyAbsoluteURL + PyMac_PRECHECK(CFURLCopyAbsoluteURL); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyAbsoluteURL(_self->ob_itself); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLGetString(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; +#ifndef CFURLGetString + PyMac_PRECHECK(CFURLGetString); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLGetString(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLGetBaseURL(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFURLRef _rv; +#ifndef CFURLGetBaseURL + PyMac_PRECHECK(CFURLGetBaseURL); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLGetBaseURL(_self->ob_itself); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCanBeDecomposed(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; +#ifndef CFURLCanBeDecomposed + PyMac_PRECHECK(CFURLCanBeDecomposed); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCanBeDecomposed(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCopyScheme(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; +#ifndef CFURLCopyScheme + PyMac_PRECHECK(CFURLCopyScheme); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyScheme(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCopyNetLocation(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; +#ifndef CFURLCopyNetLocation + PyMac_PRECHECK(CFURLCopyNetLocation); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyNetLocation(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCopyPath(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; +#ifndef CFURLCopyPath + PyMac_PRECHECK(CFURLCopyPath); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyPath(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCopyStrictPath(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + Boolean isAbsolute; +#ifndef CFURLCopyStrictPath + PyMac_PRECHECK(CFURLCopyStrictPath); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyStrictPath(_self->ob_itself, + &isAbsolute); + _res = Py_BuildValue("O&l", + CFStringRefObj_New, _rv, + isAbsolute); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCopyFileSystemPath(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + CFURLPathStyle pathStyle; +#ifndef CFURLCopyFileSystemPath + PyMac_PRECHECK(CFURLCopyFileSystemPath); +#endif + if (!PyArg_ParseTuple(_args, "l", + &pathStyle)) + return NULL; + _rv = CFURLCopyFileSystemPath(_self->ob_itself, + pathStyle); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLHasDirectoryPath(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; +#ifndef CFURLHasDirectoryPath + PyMac_PRECHECK(CFURLHasDirectoryPath); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLHasDirectoryPath(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCopyResourceSpecifier(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; +#ifndef CFURLCopyResourceSpecifier + PyMac_PRECHECK(CFURLCopyResourceSpecifier); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyResourceSpecifier(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCopyHostName(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; +#ifndef CFURLCopyHostName + PyMac_PRECHECK(CFURLCopyHostName); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyHostName(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLGetPortNumber(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + SInt32 _rv; +#ifndef CFURLGetPortNumber + PyMac_PRECHECK(CFURLGetPortNumber); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLGetPortNumber(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCopyUserName(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; +#ifndef CFURLCopyUserName + PyMac_PRECHECK(CFURLCopyUserName); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyUserName(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCopyPassword(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; +#ifndef CFURLCopyPassword + PyMac_PRECHECK(CFURLCopyPassword); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyPassword(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCopyParameterString(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + CFStringRef charactersToLeaveEscaped; +#ifndef CFURLCopyParameterString + PyMac_PRECHECK(CFURLCopyParameterString); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &charactersToLeaveEscaped)) + return NULL; + _rv = CFURLCopyParameterString(_self->ob_itself, + charactersToLeaveEscaped); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCopyQueryString(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + CFStringRef charactersToLeaveEscaped; +#ifndef CFURLCopyQueryString + PyMac_PRECHECK(CFURLCopyQueryString); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &charactersToLeaveEscaped)) + return NULL; + _rv = CFURLCopyQueryString(_self->ob_itself, + charactersToLeaveEscaped); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCopyFragment(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + CFStringRef charactersToLeaveEscaped; +#ifndef CFURLCopyFragment + PyMac_PRECHECK(CFURLCopyFragment); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &charactersToLeaveEscaped)) + return NULL; + _rv = CFURLCopyFragment(_self->ob_itself, + charactersToLeaveEscaped); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCopyLastPathComponent(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; +#ifndef CFURLCopyLastPathComponent + PyMac_PRECHECK(CFURLCopyLastPathComponent); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyLastPathComponent(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCopyPathExtension(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; +#ifndef CFURLCopyPathExtension + PyMac_PRECHECK(CFURLCopyPathExtension); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyPathExtension(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCreateCopyAppendingPathComponent(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFURLRef _rv; + CFStringRef pathComponent; + Boolean isDirectory; + if (!PyArg_ParseTuple(_args, "O&l", + CFStringRefObj_Convert, &pathComponent, + &isDirectory)) + return NULL; + _rv = CFURLCreateCopyAppendingPathComponent((CFAllocatorRef)NULL, + _self->ob_itself, + pathComponent, + isDirectory); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCreateCopyDeletingLastPathComponent(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFURLRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCreateCopyDeletingLastPathComponent((CFAllocatorRef)NULL, + _self->ob_itself); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCreateCopyAppendingPathExtension(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFURLRef _rv; + CFStringRef extension; + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &extension)) + return NULL; + _rv = CFURLCreateCopyAppendingPathExtension((CFAllocatorRef)NULL, + _self->ob_itself, + extension); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLCreateCopyDeletingPathExtension(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFURLRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCreateCopyDeletingPathExtension((CFAllocatorRef)NULL, + _self->ob_itself); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; +} + +static PyObject *CFURLRefObj_CFURLGetFSRef(CFURLRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + FSRef fsRef; +#ifndef CFURLGetFSRef + PyMac_PRECHECK(CFURLGetFSRef); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLGetFSRef(_self->ob_itself, + &fsRef); + _res = Py_BuildValue("lO&", + _rv, + PyMac_BuildFSRef, &fsRef); + return _res; +} + +static PyMethodDef CFURLRefObj_methods[] = { + {"CFURLCreateData", (PyCFunction)CFURLRefObj_CFURLCreateData, 1, + PyDoc_STR("(CFStringEncoding encoding, Boolean escapeWhitespace) -> (CFDataRef _rv)")}, + {"CFURLGetFileSystemRepresentation", (PyCFunction)CFURLRefObj_CFURLGetFileSystemRepresentation, 1, + PyDoc_STR("(Boolean resolveAgainstBase, CFIndex maxBufLen) -> (Boolean _rv, UInt8 buffer)")}, + {"CFURLCopyAbsoluteURL", (PyCFunction)CFURLRefObj_CFURLCopyAbsoluteURL, 1, + PyDoc_STR("() -> (CFURLRef _rv)")}, + {"CFURLGetString", (PyCFunction)CFURLRefObj_CFURLGetString, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLGetBaseURL", (PyCFunction)CFURLRefObj_CFURLGetBaseURL, 1, + PyDoc_STR("() -> (CFURLRef _rv)")}, + {"CFURLCanBeDecomposed", (PyCFunction)CFURLRefObj_CFURLCanBeDecomposed, 1, + PyDoc_STR("() -> (Boolean _rv)")}, + {"CFURLCopyScheme", (PyCFunction)CFURLRefObj_CFURLCopyScheme, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLCopyNetLocation", (PyCFunction)CFURLRefObj_CFURLCopyNetLocation, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLCopyPath", (PyCFunction)CFURLRefObj_CFURLCopyPath, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLCopyStrictPath", (PyCFunction)CFURLRefObj_CFURLCopyStrictPath, 1, + PyDoc_STR("() -> (CFStringRef _rv, Boolean isAbsolute)")}, + {"CFURLCopyFileSystemPath", (PyCFunction)CFURLRefObj_CFURLCopyFileSystemPath, 1, + PyDoc_STR("(CFURLPathStyle pathStyle) -> (CFStringRef _rv)")}, + {"CFURLHasDirectoryPath", (PyCFunction)CFURLRefObj_CFURLHasDirectoryPath, 1, + PyDoc_STR("() -> (Boolean _rv)")}, + {"CFURLCopyResourceSpecifier", (PyCFunction)CFURLRefObj_CFURLCopyResourceSpecifier, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLCopyHostName", (PyCFunction)CFURLRefObj_CFURLCopyHostName, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLGetPortNumber", (PyCFunction)CFURLRefObj_CFURLGetPortNumber, 1, + PyDoc_STR("() -> (SInt32 _rv)")}, + {"CFURLCopyUserName", (PyCFunction)CFURLRefObj_CFURLCopyUserName, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLCopyPassword", (PyCFunction)CFURLRefObj_CFURLCopyPassword, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLCopyParameterString", (PyCFunction)CFURLRefObj_CFURLCopyParameterString, 1, + PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")}, + {"CFURLCopyQueryString", (PyCFunction)CFURLRefObj_CFURLCopyQueryString, 1, + PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")}, + {"CFURLCopyFragment", (PyCFunction)CFURLRefObj_CFURLCopyFragment, 1, + PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")}, + {"CFURLCopyLastPathComponent", (PyCFunction)CFURLRefObj_CFURLCopyLastPathComponent, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLCopyPathExtension", (PyCFunction)CFURLRefObj_CFURLCopyPathExtension, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLCreateCopyAppendingPathComponent", (PyCFunction)CFURLRefObj_CFURLCreateCopyAppendingPathComponent, 1, + PyDoc_STR("(CFStringRef pathComponent, Boolean isDirectory) -> (CFURLRef _rv)")}, + {"CFURLCreateCopyDeletingLastPathComponent", (PyCFunction)CFURLRefObj_CFURLCreateCopyDeletingLastPathComponent, 1, + PyDoc_STR("() -> (CFURLRef _rv)")}, + {"CFURLCreateCopyAppendingPathExtension", (PyCFunction)CFURLRefObj_CFURLCreateCopyAppendingPathExtension, 1, + PyDoc_STR("(CFStringRef extension) -> (CFURLRef _rv)")}, + {"CFURLCreateCopyDeletingPathExtension", (PyCFunction)CFURLRefObj_CFURLCreateCopyDeletingPathExtension, 1, + PyDoc_STR("() -> (CFURLRef _rv)")}, + {"CFURLGetFSRef", (PyCFunction)CFURLRefObj_CFURLGetFSRef, 1, + PyDoc_STR("() -> (Boolean _rv, FSRef fsRef)")}, + {NULL, NULL, 0} +}; + +#define CFURLRefObj_getsetlist NULL + + +static int CFURLRefObj_compare(CFURLRefObject *self, CFURLRefObject *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 * CFURLRefObj_repr(CFURLRefObject *self) +{ + char buf[100]; + sprintf(buf, "", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); +} + +static int CFURLRefObj_hash(CFURLRefObject *self) +{ + /* XXXX Or should we use CFHash?? */ + return (int)self->ob_itself; +} +static int CFURLRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds) +{ + CFURLRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFURLRefObj_Convert, &itself)) + { + ((CFURLRefObject *)_self)->ob_itself = itself; + return 0; + } + + /* Any CFTypeRef descendent is allowed as initializer too */ + if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFURLRefObject *)_self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFURLRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFURLRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFURLRefObject *)self)->ob_itself = NULL; + ((CFURLRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFURLRefObj_tp_free PyObject_Del + + +PyTypeObject CFURLRef_Type = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFURLRef", /*tp_name*/ + sizeof(CFURLRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFURLRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ + (cmpfunc) CFURLRefObj_compare, /*tp_compare*/ + (reprfunc) CFURLRefObj_repr, /*tp_repr*/ + (PyNumberMethods *)0, /* tp_as_number */ + (PySequenceMethods *)0, /* tp_as_sequence */ + (PyMappingMethods *)0, /* tp_as_mapping */ + (hashfunc) CFURLRefObj_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*/ + CFURLRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFURLRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFURLRefObj_tp_init, /* tp_init */ + CFURLRefObj_tp_alloc, /* tp_alloc */ + CFURLRefObj_tp_new, /* tp_new */ + CFURLRefObj_tp_free, /* tp_free */ +}; + +/* -------------------- End object type CFURLRef -------------------- */ + + +static PyObject *CF___CFRangeMake(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFRange _rv; + CFIndex loc; + CFIndex len; +#ifndef __CFRangeMake + PyMac_PRECHECK(__CFRangeMake); +#endif + if (!PyArg_ParseTuple(_args, "ll", + &loc, + &len)) + return NULL; + _rv = __CFRangeMake(loc, + len); + _res = Py_BuildValue("O&", + CFRange_New, _rv); + return _res; +} + +static PyObject *CF_CFAllocatorGetTypeID(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFTypeID _rv; +#ifndef CFAllocatorGetTypeID + PyMac_PRECHECK(CFAllocatorGetTypeID); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFAllocatorGetTypeID(); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CF_CFAllocatorGetPreferredSizeForSize(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFIndex _rv; + CFIndex size; + CFOptionFlags hint; +#ifndef CFAllocatorGetPreferredSizeForSize + PyMac_PRECHECK(CFAllocatorGetPreferredSizeForSize); +#endif + if (!PyArg_ParseTuple(_args, "ll", + &size, + &hint)) + return NULL; + _rv = CFAllocatorGetPreferredSizeForSize((CFAllocatorRef)NULL, + size, + hint); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CF_CFCopyTypeIDDescription(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + CFTypeID type_id; +#ifndef CFCopyTypeIDDescription + PyMac_PRECHECK(CFCopyTypeIDDescription); +#endif + if (!PyArg_ParseTuple(_args, "l", + &type_id)) + return NULL; + _rv = CFCopyTypeIDDescription(type_id); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFArrayGetTypeID(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFTypeID _rv; +#ifndef CFArrayGetTypeID + PyMac_PRECHECK(CFArrayGetTypeID); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFArrayGetTypeID(); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CF_CFArrayCreateMutable(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFMutableArrayRef _rv; + CFIndex capacity; +#ifndef CFArrayCreateMutable + PyMac_PRECHECK(CFArrayCreateMutable); +#endif + if (!PyArg_ParseTuple(_args, "l", + &capacity)) + return NULL; + _rv = CFArrayCreateMutable((CFAllocatorRef)NULL, + capacity, + &kCFTypeArrayCallBacks); + _res = Py_BuildValue("O&", + CFMutableArrayRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFArrayCreateMutableCopy(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFMutableArrayRef _rv; + CFIndex capacity; + CFArrayRef theArray; +#ifndef CFArrayCreateMutableCopy + PyMac_PRECHECK(CFArrayCreateMutableCopy); +#endif + if (!PyArg_ParseTuple(_args, "lO&", + &capacity, + CFArrayRefObj_Convert, &theArray)) + return NULL; + _rv = CFArrayCreateMutableCopy((CFAllocatorRef)NULL, + capacity, + theArray); + _res = Py_BuildValue("O&", + CFMutableArrayRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFDataGetTypeID(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFTypeID _rv; +#ifndef CFDataGetTypeID + PyMac_PRECHECK(CFDataGetTypeID); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFDataGetTypeID(); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CF_CFDataCreate(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFDataRef _rv; + unsigned char *bytes__in__; + long bytes__len__; + int bytes__in_len__; +#ifndef CFDataCreate + PyMac_PRECHECK(CFDataCreate); +#endif + if (!PyArg_ParseTuple(_args, "s#", + &bytes__in__, &bytes__in_len__)) + return NULL; + bytes__len__ = bytes__in_len__; + _rv = CFDataCreate((CFAllocatorRef)NULL, + bytes__in__, bytes__len__); + _res = Py_BuildValue("O&", + CFDataRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFDataCreateWithBytesNoCopy(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFDataRef _rv; + unsigned char *bytes__in__; + long bytes__len__; + int bytes__in_len__; +#ifndef CFDataCreateWithBytesNoCopy + PyMac_PRECHECK(CFDataCreateWithBytesNoCopy); +#endif + if (!PyArg_ParseTuple(_args, "s#", + &bytes__in__, &bytes__in_len__)) + return NULL; + bytes__len__ = bytes__in_len__; + _rv = CFDataCreateWithBytesNoCopy((CFAllocatorRef)NULL, + bytes__in__, bytes__len__, + (CFAllocatorRef)NULL); + _res = Py_BuildValue("O&", + CFDataRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFDataCreateMutable(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFMutableDataRef _rv; + CFIndex capacity; +#ifndef CFDataCreateMutable + PyMac_PRECHECK(CFDataCreateMutable); +#endif + if (!PyArg_ParseTuple(_args, "l", + &capacity)) + return NULL; + _rv = CFDataCreateMutable((CFAllocatorRef)NULL, + capacity); + _res = Py_BuildValue("O&", + CFMutableDataRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFDataCreateMutableCopy(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFMutableDataRef _rv; + CFIndex capacity; + CFDataRef theData; +#ifndef CFDataCreateMutableCopy + PyMac_PRECHECK(CFDataCreateMutableCopy); +#endif + if (!PyArg_ParseTuple(_args, "lO&", + &capacity, + CFDataRefObj_Convert, &theData)) + return NULL; + _rv = CFDataCreateMutableCopy((CFAllocatorRef)NULL, + capacity, + theData); + _res = Py_BuildValue("O&", + CFMutableDataRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFDictionaryGetTypeID(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFTypeID _rv; +#ifndef CFDictionaryGetTypeID + PyMac_PRECHECK(CFDictionaryGetTypeID); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFDictionaryGetTypeID(); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CF_CFDictionaryCreateMutable(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFMutableDictionaryRef _rv; + CFIndex capacity; +#ifndef CFDictionaryCreateMutable + PyMac_PRECHECK(CFDictionaryCreateMutable); +#endif + if (!PyArg_ParseTuple(_args, "l", + &capacity)) + return NULL; + _rv = CFDictionaryCreateMutable((CFAllocatorRef)NULL, + capacity, + &kCFTypeDictionaryKeyCallBacks, + &kCFTypeDictionaryValueCallBacks); + _res = Py_BuildValue("O&", + CFMutableDictionaryRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFDictionaryCreateMutableCopy(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFMutableDictionaryRef _rv; + CFIndex capacity; + CFDictionaryRef theDict; +#ifndef CFDictionaryCreateMutableCopy + PyMac_PRECHECK(CFDictionaryCreateMutableCopy); +#endif + if (!PyArg_ParseTuple(_args, "lO&", + &capacity, + CFDictionaryRefObj_Convert, &theDict)) + return NULL; + _rv = CFDictionaryCreateMutableCopy((CFAllocatorRef)NULL, + capacity, + theDict); + _res = Py_BuildValue("O&", + CFMutableDictionaryRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFPreferencesCopyAppValue(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFTypeRef _rv; + CFStringRef key; + CFStringRef applicationID; +#ifndef CFPreferencesCopyAppValue + PyMac_PRECHECK(CFPreferencesCopyAppValue); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CFStringRefObj_Convert, &key, + CFStringRefObj_Convert, &applicationID)) + return NULL; + _rv = CFPreferencesCopyAppValue(key, + applicationID); + _res = Py_BuildValue("O&", + CFTypeRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFPreferencesGetAppBooleanValue(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + CFStringRef key; + CFStringRef applicationID; + Boolean keyExistsAndHasValidFormat; +#ifndef CFPreferencesGetAppBooleanValue + PyMac_PRECHECK(CFPreferencesGetAppBooleanValue); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CFStringRefObj_Convert, &key, + CFStringRefObj_Convert, &applicationID)) + return NULL; + _rv = CFPreferencesGetAppBooleanValue(key, + applicationID, + &keyExistsAndHasValidFormat); + _res = Py_BuildValue("ll", + _rv, + keyExistsAndHasValidFormat); + return _res; +} + +static PyObject *CF_CFPreferencesGetAppIntegerValue(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFIndex _rv; + CFStringRef key; + CFStringRef applicationID; + Boolean keyExistsAndHasValidFormat; +#ifndef CFPreferencesGetAppIntegerValue + PyMac_PRECHECK(CFPreferencesGetAppIntegerValue); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CFStringRefObj_Convert, &key, + CFStringRefObj_Convert, &applicationID)) + return NULL; + _rv = CFPreferencesGetAppIntegerValue(key, + applicationID, + &keyExistsAndHasValidFormat); + _res = Py_BuildValue("ll", + _rv, + keyExistsAndHasValidFormat); + return _res; +} + +static PyObject *CF_CFPreferencesSetAppValue(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef key; + CFTypeRef value; + CFStringRef applicationID; +#ifndef CFPreferencesSetAppValue + PyMac_PRECHECK(CFPreferencesSetAppValue); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + CFStringRefObj_Convert, &key, + CFTypeRefObj_Convert, &value, + CFStringRefObj_Convert, &applicationID)) + return NULL; + CFPreferencesSetAppValue(key, + value, + applicationID); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CF_CFPreferencesAddSuitePreferencesToApp(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef applicationID; + CFStringRef suiteID; +#ifndef CFPreferencesAddSuitePreferencesToApp + PyMac_PRECHECK(CFPreferencesAddSuitePreferencesToApp); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CFStringRefObj_Convert, &applicationID, + CFStringRefObj_Convert, &suiteID)) + return NULL; + CFPreferencesAddSuitePreferencesToApp(applicationID, + suiteID); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CF_CFPreferencesRemoveSuitePreferencesFromApp(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef applicationID; + CFStringRef suiteID; +#ifndef CFPreferencesRemoveSuitePreferencesFromApp + PyMac_PRECHECK(CFPreferencesRemoveSuitePreferencesFromApp); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CFStringRefObj_Convert, &applicationID, + CFStringRefObj_Convert, &suiteID)) + return NULL; + CFPreferencesRemoveSuitePreferencesFromApp(applicationID, + suiteID); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CF_CFPreferencesAppSynchronize(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + CFStringRef applicationID; +#ifndef CFPreferencesAppSynchronize + PyMac_PRECHECK(CFPreferencesAppSynchronize); +#endif + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &applicationID)) + return NULL; + _rv = CFPreferencesAppSynchronize(applicationID); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CF_CFPreferencesCopyValue(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFTypeRef _rv; + CFStringRef key; + CFStringRef applicationID; + CFStringRef userName; + CFStringRef hostName; +#ifndef CFPreferencesCopyValue + PyMac_PRECHECK(CFPreferencesCopyValue); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&O&", + CFStringRefObj_Convert, &key, + CFStringRefObj_Convert, &applicationID, + CFStringRefObj_Convert, &userName, + CFStringRefObj_Convert, &hostName)) + return NULL; + _rv = CFPreferencesCopyValue(key, + applicationID, + userName, + hostName); + _res = Py_BuildValue("O&", + CFTypeRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFPreferencesCopyMultiple(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFDictionaryRef _rv; + CFArrayRef keysToFetch; + CFStringRef applicationID; + CFStringRef userName; + CFStringRef hostName; +#ifndef CFPreferencesCopyMultiple + PyMac_PRECHECK(CFPreferencesCopyMultiple); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&O&", + CFArrayRefObj_Convert, &keysToFetch, + CFStringRefObj_Convert, &applicationID, + CFStringRefObj_Convert, &userName, + CFStringRefObj_Convert, &hostName)) + return NULL; + _rv = CFPreferencesCopyMultiple(keysToFetch, + applicationID, + userName, + hostName); + _res = Py_BuildValue("O&", + CFDictionaryRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFPreferencesSetValue(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef key; + CFTypeRef value; + CFStringRef applicationID; + CFStringRef userName; + CFStringRef hostName; +#ifndef CFPreferencesSetValue + PyMac_PRECHECK(CFPreferencesSetValue); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&O&O&", + CFStringRefObj_Convert, &key, + CFTypeRefObj_Convert, &value, + CFStringRefObj_Convert, &applicationID, + CFStringRefObj_Convert, &userName, + CFStringRefObj_Convert, &hostName)) + return NULL; + CFPreferencesSetValue(key, + value, + applicationID, + userName, + hostName); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CF_CFPreferencesSetMultiple(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFDictionaryRef keysToSet; + CFArrayRef keysToRemove; + CFStringRef applicationID; + CFStringRef userName; + CFStringRef hostName; +#ifndef CFPreferencesSetMultiple + PyMac_PRECHECK(CFPreferencesSetMultiple); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&O&O&", + CFDictionaryRefObj_Convert, &keysToSet, + CFArrayRefObj_Convert, &keysToRemove, + CFStringRefObj_Convert, &applicationID, + CFStringRefObj_Convert, &userName, + CFStringRefObj_Convert, &hostName)) + return NULL; + CFPreferencesSetMultiple(keysToSet, + keysToRemove, + applicationID, + userName, + hostName); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *CF_CFPreferencesSynchronize(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + CFStringRef applicationID; + CFStringRef userName; + CFStringRef hostName; +#ifndef CFPreferencesSynchronize + PyMac_PRECHECK(CFPreferencesSynchronize); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + CFStringRefObj_Convert, &applicationID, + CFStringRefObj_Convert, &userName, + CFStringRefObj_Convert, &hostName)) + return NULL; + _rv = CFPreferencesSynchronize(applicationID, + userName, + hostName); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CF_CFPreferencesCopyApplicationList(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFArrayRef _rv; + CFStringRef userName; + CFStringRef hostName; +#ifndef CFPreferencesCopyApplicationList + PyMac_PRECHECK(CFPreferencesCopyApplicationList); +#endif + if (!PyArg_ParseTuple(_args, "O&O&", + CFStringRefObj_Convert, &userName, + CFStringRefObj_Convert, &hostName)) + return NULL; + _rv = CFPreferencesCopyApplicationList(userName, + hostName); + _res = Py_BuildValue("O&", + CFArrayRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFPreferencesCopyKeyList(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFArrayRef _rv; + CFStringRef applicationID; + CFStringRef userName; + CFStringRef hostName; +#ifndef CFPreferencesCopyKeyList + PyMac_PRECHECK(CFPreferencesCopyKeyList); +#endif + if (!PyArg_ParseTuple(_args, "O&O&O&", + CFStringRefObj_Convert, &applicationID, + CFStringRefObj_Convert, &userName, + CFStringRefObj_Convert, &hostName)) + return NULL; + _rv = CFPreferencesCopyKeyList(applicationID, + userName, + hostName); + _res = Py_BuildValue("O&", + CFArrayRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFStringGetTypeID(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFTypeID _rv; +#ifndef CFStringGetTypeID + PyMac_PRECHECK(CFStringGetTypeID); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFStringGetTypeID(); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CF_CFStringCreateWithPascalString(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + Str255 pStr; + CFStringEncoding encoding; +#ifndef CFStringCreateWithPascalString + PyMac_PRECHECK(CFStringCreateWithPascalString); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + PyMac_GetStr255, pStr, + &encoding)) + return NULL; + _rv = CFStringCreateWithPascalString((CFAllocatorRef)NULL, + pStr, + encoding); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFStringCreateWithCString(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + char* cStr; + CFStringEncoding encoding; +#ifndef CFStringCreateWithCString + PyMac_PRECHECK(CFStringCreateWithCString); +#endif + if (!PyArg_ParseTuple(_args, "sl", + &cStr, + &encoding)) + return NULL; + _rv = CFStringCreateWithCString((CFAllocatorRef)NULL, + cStr, + encoding); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFStringCreateWithCharacters(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + UniChar *chars__in__; + UniCharCount chars__len__; + int chars__in_len__; +#ifndef CFStringCreateWithCharacters + PyMac_PRECHECK(CFStringCreateWithCharacters); +#endif + if (!PyArg_ParseTuple(_args, "u#", + &chars__in__, &chars__in_len__)) + return NULL; + chars__len__ = chars__in_len__; + _rv = CFStringCreateWithCharacters((CFAllocatorRef)NULL, + chars__in__, chars__len__); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFStringCreateWithPascalStringNoCopy(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + Str255 pStr; + CFStringEncoding encoding; +#ifndef CFStringCreateWithPascalStringNoCopy + PyMac_PRECHECK(CFStringCreateWithPascalStringNoCopy); +#endif + if (!PyArg_ParseTuple(_args, "O&l", + PyMac_GetStr255, pStr, + &encoding)) + return NULL; + _rv = CFStringCreateWithPascalStringNoCopy((CFAllocatorRef)NULL, + pStr, + encoding, + (CFAllocatorRef)NULL); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFStringCreateWithCStringNoCopy(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + char* cStr; + CFStringEncoding encoding; +#ifndef CFStringCreateWithCStringNoCopy + PyMac_PRECHECK(CFStringCreateWithCStringNoCopy); +#endif + if (!PyArg_ParseTuple(_args, "sl", + &cStr, + &encoding)) + return NULL; + _rv = CFStringCreateWithCStringNoCopy((CFAllocatorRef)NULL, + cStr, + encoding, + (CFAllocatorRef)NULL); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFStringCreateWithCharactersNoCopy(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + UniChar *chars__in__; + UniCharCount chars__len__; + int chars__in_len__; +#ifndef CFStringCreateWithCharactersNoCopy + PyMac_PRECHECK(CFStringCreateWithCharactersNoCopy); +#endif + if (!PyArg_ParseTuple(_args, "u#", + &chars__in__, &chars__in_len__)) + return NULL; + chars__len__ = chars__in_len__; + _rv = CFStringCreateWithCharactersNoCopy((CFAllocatorRef)NULL, + chars__in__, chars__len__, + (CFAllocatorRef)NULL); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFStringCreateMutable(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFMutableStringRef _rv; + CFIndex maxLength; +#ifndef CFStringCreateMutable + PyMac_PRECHECK(CFStringCreateMutable); +#endif + if (!PyArg_ParseTuple(_args, "l", + &maxLength)) + return NULL; + _rv = CFStringCreateMutable((CFAllocatorRef)NULL, + maxLength); + _res = Py_BuildValue("O&", + CFMutableStringRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFStringCreateMutableCopy(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFMutableStringRef _rv; + CFIndex maxLength; + CFStringRef theString; +#ifndef CFStringCreateMutableCopy + PyMac_PRECHECK(CFStringCreateMutableCopy); +#endif + if (!PyArg_ParseTuple(_args, "lO&", + &maxLength, + CFStringRefObj_Convert, &theString)) + return NULL; + _rv = CFStringCreateMutableCopy((CFAllocatorRef)NULL, + maxLength, + theString); + _res = Py_BuildValue("O&", + CFMutableStringRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFStringCreateWithBytes(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + unsigned char *bytes__in__; + long bytes__len__; + int bytes__in_len__; + CFStringEncoding encoding; + Boolean isExternalRepresentation; +#ifndef CFStringCreateWithBytes + PyMac_PRECHECK(CFStringCreateWithBytes); +#endif + if (!PyArg_ParseTuple(_args, "s#ll", + &bytes__in__, &bytes__in_len__, + &encoding, + &isExternalRepresentation)) + return NULL; + bytes__len__ = bytes__in_len__; + _rv = CFStringCreateWithBytes((CFAllocatorRef)NULL, + bytes__in__, bytes__len__, + encoding, + isExternalRepresentation); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFStringGetSystemEncoding(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringEncoding _rv; +#ifndef CFStringGetSystemEncoding + PyMac_PRECHECK(CFStringGetSystemEncoding); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFStringGetSystemEncoding(); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CF_CFStringGetMaximumSizeForEncoding(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFIndex _rv; + CFIndex length; + CFStringEncoding encoding; +#ifndef CFStringGetMaximumSizeForEncoding + PyMac_PRECHECK(CFStringGetMaximumSizeForEncoding); +#endif + if (!PyArg_ParseTuple(_args, "ll", + &length, + &encoding)) + return NULL; + _rv = CFStringGetMaximumSizeForEncoding(length, + encoding); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CF_CFStringIsEncodingAvailable(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + Boolean _rv; + CFStringEncoding encoding; +#ifndef CFStringIsEncodingAvailable + PyMac_PRECHECK(CFStringIsEncodingAvailable); +#endif + if (!PyArg_ParseTuple(_args, "l", + &encoding)) + return NULL; + _rv = CFStringIsEncodingAvailable(encoding); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CF_CFStringGetNameOfEncoding(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + CFStringEncoding encoding; +#ifndef CFStringGetNameOfEncoding + PyMac_PRECHECK(CFStringGetNameOfEncoding); +#endif + if (!PyArg_ParseTuple(_args, "l", + &encoding)) + return NULL; + _rv = CFStringGetNameOfEncoding(encoding); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFStringConvertEncodingToNSStringEncoding(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + UInt32 _rv; + CFStringEncoding encoding; +#ifndef CFStringConvertEncodingToNSStringEncoding + PyMac_PRECHECK(CFStringConvertEncodingToNSStringEncoding); +#endif + if (!PyArg_ParseTuple(_args, "l", + &encoding)) + return NULL; + _rv = CFStringConvertEncodingToNSStringEncoding(encoding); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CF_CFStringConvertNSStringEncodingToEncoding(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringEncoding _rv; + UInt32 encoding; +#ifndef CFStringConvertNSStringEncodingToEncoding + PyMac_PRECHECK(CFStringConvertNSStringEncodingToEncoding); +#endif + if (!PyArg_ParseTuple(_args, "l", + &encoding)) + return NULL; + _rv = CFStringConvertNSStringEncodingToEncoding(encoding); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CF_CFStringConvertEncodingToWindowsCodepage(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + UInt32 _rv; + CFStringEncoding encoding; +#ifndef CFStringConvertEncodingToWindowsCodepage + PyMac_PRECHECK(CFStringConvertEncodingToWindowsCodepage); +#endif + if (!PyArg_ParseTuple(_args, "l", + &encoding)) + return NULL; + _rv = CFStringConvertEncodingToWindowsCodepage(encoding); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CF_CFStringConvertWindowsCodepageToEncoding(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringEncoding _rv; + UInt32 codepage; +#ifndef CFStringConvertWindowsCodepageToEncoding + PyMac_PRECHECK(CFStringConvertWindowsCodepageToEncoding); +#endif + if (!PyArg_ParseTuple(_args, "l", + &codepage)) + return NULL; + _rv = CFStringConvertWindowsCodepageToEncoding(codepage); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CF_CFStringConvertEncodingToIANACharSetName(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + CFStringEncoding encoding; +#ifndef CFStringConvertEncodingToIANACharSetName + PyMac_PRECHECK(CFStringConvertEncodingToIANACharSetName); +#endif + if (!PyArg_ParseTuple(_args, "l", + &encoding)) + return NULL; + _rv = CFStringConvertEncodingToIANACharSetName(encoding); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFStringGetMostCompatibleMacStringEncoding(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringEncoding _rv; + CFStringEncoding encoding; +#ifndef CFStringGetMostCompatibleMacStringEncoding + PyMac_PRECHECK(CFStringGetMostCompatibleMacStringEncoding); +#endif + if (!PyArg_ParseTuple(_args, "l", + &encoding)) + return NULL; + _rv = CFStringGetMostCompatibleMacStringEncoding(encoding); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CF___CFStringMakeConstantString(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFStringRef _rv; + char* cStr; +#ifndef __CFStringMakeConstantString + PyMac_PRECHECK(__CFStringMakeConstantString); +#endif + if (!PyArg_ParseTuple(_args, "s", + &cStr)) + return NULL; + _rv = __CFStringMakeConstantString(cStr); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFURLGetTypeID(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFTypeID _rv; +#ifndef CFURLGetTypeID + PyMac_PRECHECK(CFURLGetTypeID); +#endif + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLGetTypeID(); + _res = Py_BuildValue("l", + _rv); + return _res; +} + +static PyObject *CF_CFURLCreateWithBytes(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFURLRef _rv; + unsigned char *URLBytes__in__; + long URLBytes__len__; + int URLBytes__in_len__; + CFStringEncoding encoding; + CFURLRef baseURL; +#ifndef CFURLCreateWithBytes + PyMac_PRECHECK(CFURLCreateWithBytes); +#endif + if (!PyArg_ParseTuple(_args, "s#lO&", + &URLBytes__in__, &URLBytes__in_len__, + &encoding, + OptionalCFURLRefObj_Convert, &baseURL)) + return NULL; + URLBytes__len__ = URLBytes__in_len__; + _rv = CFURLCreateWithBytes((CFAllocatorRef)NULL, + URLBytes__in__, URLBytes__len__, + encoding, + baseURL); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFURLCreateFromFileSystemRepresentation(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFURLRef _rv; + unsigned char *buffer__in__; + long buffer__len__; + int buffer__in_len__; + Boolean isDirectory; +#ifndef CFURLCreateFromFileSystemRepresentation + PyMac_PRECHECK(CFURLCreateFromFileSystemRepresentation); +#endif + if (!PyArg_ParseTuple(_args, "s#l", + &buffer__in__, &buffer__in_len__, + &isDirectory)) + return NULL; + buffer__len__ = buffer__in_len__; + _rv = CFURLCreateFromFileSystemRepresentation((CFAllocatorRef)NULL, + buffer__in__, buffer__len__, + isDirectory); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFURLCreateFromFileSystemRepresentationRelativeToBase(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFURLRef _rv; + unsigned char *buffer__in__; + long buffer__len__; + int buffer__in_len__; + Boolean isDirectory; + CFURLRef baseURL; +#ifndef CFURLCreateFromFileSystemRepresentationRelativeToBase + PyMac_PRECHECK(CFURLCreateFromFileSystemRepresentationRelativeToBase); +#endif + if (!PyArg_ParseTuple(_args, "s#lO&", + &buffer__in__, &buffer__in_len__, + &isDirectory, + OptionalCFURLRefObj_Convert, &baseURL)) + return NULL; + buffer__len__ = buffer__in_len__; + _rv = CFURLCreateFromFileSystemRepresentationRelativeToBase((CFAllocatorRef)NULL, + buffer__in__, buffer__len__, + isDirectory, + baseURL); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; +} + +static PyObject *CF_CFURLCreateFromFSRef(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFURLRef _rv; + FSRef fsRef; +#ifndef CFURLCreateFromFSRef + PyMac_PRECHECK(CFURLCreateFromFSRef); +#endif + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSRef, &fsRef)) + return NULL; + _rv = CFURLCreateFromFSRef((CFAllocatorRef)NULL, + &fsRef); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; +} + +static PyObject *CF_toCF(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + + CFTypeRef rv; + CFTypeID typeid; + + if (!PyArg_ParseTuple(_args, "O&", PyCF_Python2CF, &rv)) + return NULL; + typeid = CFGetTypeID(rv); + + if (typeid == CFStringGetTypeID()) + return Py_BuildValue("O&", CFStringRefObj_New, rv); + if (typeid == CFArrayGetTypeID()) + return Py_BuildValue("O&", CFArrayRefObj_New, rv); + if (typeid == CFDictionaryGetTypeID()) + return Py_BuildValue("O&", CFDictionaryRefObj_New, rv); + if (typeid == CFURLGetTypeID()) + return Py_BuildValue("O&", CFURLRefObj_New, rv); + + _res = Py_BuildValue("O&", CFTypeRefObj_New, rv); + return _res; + +} + +static PyMethodDef CF_methods[] = { + {"__CFRangeMake", (PyCFunction)CF___CFRangeMake, 1, + PyDoc_STR("(CFIndex loc, CFIndex len) -> (CFRange _rv)")}, + {"CFAllocatorGetTypeID", (PyCFunction)CF_CFAllocatorGetTypeID, 1, + PyDoc_STR("() -> (CFTypeID _rv)")}, + {"CFAllocatorGetPreferredSizeForSize", (PyCFunction)CF_CFAllocatorGetPreferredSizeForSize, 1, + PyDoc_STR("(CFIndex size, CFOptionFlags hint) -> (CFIndex _rv)")}, + {"CFCopyTypeIDDescription", (PyCFunction)CF_CFCopyTypeIDDescription, 1, + PyDoc_STR("(CFTypeID type_id) -> (CFStringRef _rv)")}, + {"CFArrayGetTypeID", (PyCFunction)CF_CFArrayGetTypeID, 1, + PyDoc_STR("() -> (CFTypeID _rv)")}, + {"CFArrayCreateMutable", (PyCFunction)CF_CFArrayCreateMutable, 1, + PyDoc_STR("(CFIndex capacity) -> (CFMutableArrayRef _rv)")}, + {"CFArrayCreateMutableCopy", (PyCFunction)CF_CFArrayCreateMutableCopy, 1, + PyDoc_STR("(CFIndex capacity, CFArrayRef theArray) -> (CFMutableArrayRef _rv)")}, + {"CFDataGetTypeID", (PyCFunction)CF_CFDataGetTypeID, 1, + PyDoc_STR("() -> (CFTypeID _rv)")}, + {"CFDataCreate", (PyCFunction)CF_CFDataCreate, 1, + PyDoc_STR("(Buffer bytes) -> (CFDataRef _rv)")}, + {"CFDataCreateWithBytesNoCopy", (PyCFunction)CF_CFDataCreateWithBytesNoCopy, 1, + PyDoc_STR("(Buffer bytes) -> (CFDataRef _rv)")}, + {"CFDataCreateMutable", (PyCFunction)CF_CFDataCreateMutable, 1, + PyDoc_STR("(CFIndex capacity) -> (CFMutableDataRef _rv)")}, + {"CFDataCreateMutableCopy", (PyCFunction)CF_CFDataCreateMutableCopy, 1, + PyDoc_STR("(CFIndex capacity, CFDataRef theData) -> (CFMutableDataRef _rv)")}, + {"CFDictionaryGetTypeID", (PyCFunction)CF_CFDictionaryGetTypeID, 1, + PyDoc_STR("() -> (CFTypeID _rv)")}, + {"CFDictionaryCreateMutable", (PyCFunction)CF_CFDictionaryCreateMutable, 1, + PyDoc_STR("(CFIndex capacity) -> (CFMutableDictionaryRef _rv)")}, + {"CFDictionaryCreateMutableCopy", (PyCFunction)CF_CFDictionaryCreateMutableCopy, 1, + PyDoc_STR("(CFIndex capacity, CFDictionaryRef theDict) -> (CFMutableDictionaryRef _rv)")}, + {"CFPreferencesCopyAppValue", (PyCFunction)CF_CFPreferencesCopyAppValue, 1, + PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (CFTypeRef _rv)")}, + {"CFPreferencesGetAppBooleanValue", (PyCFunction)CF_CFPreferencesGetAppBooleanValue, 1, + PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (Boolean _rv, Boolean keyExistsAndHasValidFormat)")}, + {"CFPreferencesGetAppIntegerValue", (PyCFunction)CF_CFPreferencesGetAppIntegerValue, 1, + PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (CFIndex _rv, Boolean keyExistsAndHasValidFormat)")}, + {"CFPreferencesSetAppValue", (PyCFunction)CF_CFPreferencesSetAppValue, 1, + PyDoc_STR("(CFStringRef key, CFTypeRef value, CFStringRef applicationID) -> None")}, + {"CFPreferencesAddSuitePreferencesToApp", (PyCFunction)CF_CFPreferencesAddSuitePreferencesToApp, 1, + PyDoc_STR("(CFStringRef applicationID, CFStringRef suiteID) -> None")}, + {"CFPreferencesRemoveSuitePreferencesFromApp", (PyCFunction)CF_CFPreferencesRemoveSuitePreferencesFromApp, 1, + PyDoc_STR("(CFStringRef applicationID, CFStringRef suiteID) -> None")}, + {"CFPreferencesAppSynchronize", (PyCFunction)CF_CFPreferencesAppSynchronize, 1, + PyDoc_STR("(CFStringRef applicationID) -> (Boolean _rv)")}, + {"CFPreferencesCopyValue", (PyCFunction)CF_CFPreferencesCopyValue, 1, + PyDoc_STR("(CFStringRef key, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFTypeRef _rv)")}, + {"CFPreferencesCopyMultiple", (PyCFunction)CF_CFPreferencesCopyMultiple, 1, + PyDoc_STR("(CFArrayRef keysToFetch, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFDictionaryRef _rv)")}, + {"CFPreferencesSetValue", (PyCFunction)CF_CFPreferencesSetValue, 1, + PyDoc_STR("(CFStringRef key, CFTypeRef value, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None")}, + {"CFPreferencesSetMultiple", (PyCFunction)CF_CFPreferencesSetMultiple, 1, + PyDoc_STR("(CFDictionaryRef keysToSet, CFArrayRef keysToRemove, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None")}, + {"CFPreferencesSynchronize", (PyCFunction)CF_CFPreferencesSynchronize, 1, + PyDoc_STR("(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (Boolean _rv)")}, + {"CFPreferencesCopyApplicationList", (PyCFunction)CF_CFPreferencesCopyApplicationList, 1, + PyDoc_STR("(CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)")}, + {"CFPreferencesCopyKeyList", (PyCFunction)CF_CFPreferencesCopyKeyList, 1, + PyDoc_STR("(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)")}, + {"CFStringGetTypeID", (PyCFunction)CF_CFStringGetTypeID, 1, + PyDoc_STR("() -> (CFTypeID _rv)")}, + {"CFStringCreateWithPascalString", (PyCFunction)CF_CFStringCreateWithPascalString, 1, + PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)")}, + {"CFStringCreateWithCString", (PyCFunction)CF_CFStringCreateWithCString, 1, + PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)")}, + {"CFStringCreateWithCharacters", (PyCFunction)CF_CFStringCreateWithCharacters, 1, + PyDoc_STR("(Buffer chars) -> (CFStringRef _rv)")}, + {"CFStringCreateWithPascalStringNoCopy", (PyCFunction)CF_CFStringCreateWithPascalStringNoCopy, 1, + PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)")}, + {"CFStringCreateWithCStringNoCopy", (PyCFunction)CF_CFStringCreateWithCStringNoCopy, 1, + PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)")}, + {"CFStringCreateWithCharactersNoCopy", (PyCFunction)CF_CFStringCreateWithCharactersNoCopy, 1, + PyDoc_STR("(Buffer chars) -> (CFStringRef _rv)")}, + {"CFStringCreateMutable", (PyCFunction)CF_CFStringCreateMutable, 1, + PyDoc_STR("(CFIndex maxLength) -> (CFMutableStringRef _rv)")}, + {"CFStringCreateMutableCopy", (PyCFunction)CF_CFStringCreateMutableCopy, 1, + PyDoc_STR("(CFIndex maxLength, CFStringRef theString) -> (CFMutableStringRef _rv)")}, + {"CFStringCreateWithBytes", (PyCFunction)CF_CFStringCreateWithBytes, 1, + PyDoc_STR("(Buffer bytes, CFStringEncoding encoding, Boolean isExternalRepresentation) -> (CFStringRef _rv)")}, + {"CFStringGetSystemEncoding", (PyCFunction)CF_CFStringGetSystemEncoding, 1, + PyDoc_STR("() -> (CFStringEncoding _rv)")}, + {"CFStringGetMaximumSizeForEncoding", (PyCFunction)CF_CFStringGetMaximumSizeForEncoding, 1, + PyDoc_STR("(CFIndex length, CFStringEncoding encoding) -> (CFIndex _rv)")}, + {"CFStringIsEncodingAvailable", (PyCFunction)CF_CFStringIsEncodingAvailable, 1, + PyDoc_STR("(CFStringEncoding encoding) -> (Boolean _rv)")}, + {"CFStringGetNameOfEncoding", (PyCFunction)CF_CFStringGetNameOfEncoding, 1, + PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")}, + {"CFStringConvertEncodingToNSStringEncoding", (PyCFunction)CF_CFStringConvertEncodingToNSStringEncoding, 1, + PyDoc_STR("(CFStringEncoding encoding) -> (UInt32 _rv)")}, + {"CFStringConvertNSStringEncodingToEncoding", (PyCFunction)CF_CFStringConvertNSStringEncodingToEncoding, 1, + PyDoc_STR("(UInt32 encoding) -> (CFStringEncoding _rv)")}, + {"CFStringConvertEncodingToWindowsCodepage", (PyCFunction)CF_CFStringConvertEncodingToWindowsCodepage, 1, + PyDoc_STR("(CFStringEncoding encoding) -> (UInt32 _rv)")}, + {"CFStringConvertWindowsCodepageToEncoding", (PyCFunction)CF_CFStringConvertWindowsCodepageToEncoding, 1, + PyDoc_STR("(UInt32 codepage) -> (CFStringEncoding _rv)")}, + {"CFStringConvertEncodingToIANACharSetName", (PyCFunction)CF_CFStringConvertEncodingToIANACharSetName, 1, + PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")}, + {"CFStringGetMostCompatibleMacStringEncoding", (PyCFunction)CF_CFStringGetMostCompatibleMacStringEncoding, 1, + PyDoc_STR("(CFStringEncoding encoding) -> (CFStringEncoding _rv)")}, + {"__CFStringMakeConstantString", (PyCFunction)CF___CFStringMakeConstantString, 1, + PyDoc_STR("(char* cStr) -> (CFStringRef _rv)")}, + {"CFURLGetTypeID", (PyCFunction)CF_CFURLGetTypeID, 1, + PyDoc_STR("() -> (CFTypeID _rv)")}, + {"CFURLCreateWithBytes", (PyCFunction)CF_CFURLCreateWithBytes, 1, + PyDoc_STR("(Buffer URLBytes, CFStringEncoding encoding, CFURLRef baseURL) -> (CFURLRef _rv)")}, + {"CFURLCreateFromFileSystemRepresentation", (PyCFunction)CF_CFURLCreateFromFileSystemRepresentation, 1, + PyDoc_STR("(Buffer buffer, Boolean isDirectory) -> (CFURLRef _rv)")}, + {"CFURLCreateFromFileSystemRepresentationRelativeToBase", (PyCFunction)CF_CFURLCreateFromFileSystemRepresentationRelativeToBase, 1, + PyDoc_STR("(Buffer buffer, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)")}, + {"CFURLCreateFromFSRef", (PyCFunction)CF_CFURLCreateFromFSRef, 1, + PyDoc_STR("(FSRef fsRef) -> (CFURLRef _rv)")}, + {"toCF", (PyCFunction)CF_toCF, 1, + PyDoc_STR("(python_object) -> (CF_object)")}, + {NULL, NULL, 0} +}; + + + + +/* Routines to convert any CF type to/from the corresponding CFxxxObj */ +PyObject *CFObj_New(CFTypeRef itself) +{ + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + if (CFGetTypeID(itself) == CFArrayGetTypeID()) return CFArrayRefObj_New((CFArrayRef)itself); + if (CFGetTypeID(itself) == CFDictionaryGetTypeID()) return CFDictionaryRefObj_New((CFDictionaryRef)itself); + if (CFGetTypeID(itself) == CFDataGetTypeID()) return CFDataRefObj_New((CFDataRef)itself); + if (CFGetTypeID(itself) == CFStringGetTypeID()) return CFStringRefObj_New((CFStringRef)itself); + if (CFGetTypeID(itself) == CFURLGetTypeID()) return CFURLRefObj_New((CFURLRef)itself); + /* XXXX Or should we use PyCF_CF2Python here?? */ + return CFTypeRefObj_New(itself); +} +int CFObj_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) && + !CFArrayRefObj_Check(v) && + !CFMutableArrayRefObj_Check(v) && + !CFDictionaryRefObj_Check(v) && + !CFMutableDictionaryRefObj_Check(v) && + !CFDataRefObj_Check(v) && + !CFMutableDataRefObj_Check(v) && + !CFStringRefObj_Check(v) && + !CFMutableStringRefObj_Check(v) && + !CFURLRefObj_Check(v) ) + { + /* XXXX Or should we use PyCF_Python2CF here?? */ + PyErr_SetString(PyExc_TypeError, "CF object required"); + return 0; + } + *p_itself = ((CFTypeRefObject *)v)->ob_itself; + return 1; +} + + +void init_CF(void) +{ + PyObject *m; + PyObject *d; + + + + PyMac_INIT_TOOLBOX_OBJECT_NEW(CFTypeRef, CFObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFTypeRef, CFObj_Convert); + PyMac_INIT_TOOLBOX_OBJECT_NEW(CFTypeRef, CFTypeRefObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFTypeRef, CFTypeRefObj_Convert); + PyMac_INIT_TOOLBOX_OBJECT_NEW(CFStringRef, CFStringRefObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFStringRef, CFStringRefObj_Convert); + PyMac_INIT_TOOLBOX_OBJECT_NEW(CFMutableStringRef, CFMutableStringRefObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFMutableStringRef, CFMutableStringRefObj_Convert); + PyMac_INIT_TOOLBOX_OBJECT_NEW(CFArrayRef, CFArrayRefObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFArrayRef, CFArrayRefObj_Convert); + PyMac_INIT_TOOLBOX_OBJECT_NEW(CFMutableArrayRef, CFMutableArrayRefObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFMutableArrayRef, CFMutableArrayRefObj_Convert); + PyMac_INIT_TOOLBOX_OBJECT_NEW(CFDictionaryRef, CFDictionaryRefObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFDictionaryRef, CFDictionaryRefObj_Convert); + PyMac_INIT_TOOLBOX_OBJECT_NEW(CFMutableDictionaryRef, CFMutableDictionaryRefObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFMutableDictionaryRef, CFMutableDictionaryRefObj_Convert); + PyMac_INIT_TOOLBOX_OBJECT_NEW(CFURLRef, CFURLRefObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFURLRef, CFURLRefObj_Convert); + + + m = Py_InitModule("_CF", CF_methods); + d = PyModule_GetDict(m); + CF_Error = PyMac_GetOSErrException(); + if (CF_Error == NULL || + PyDict_SetItemString(d, "Error", CF_Error) != 0) + return; + CFTypeRef_Type.ob_type = &PyType_Type; + if (PyType_Ready(&CFTypeRef_Type) < 0) return; + Py_INCREF(&CFTypeRef_Type); + PyModule_AddObject(m, "CFTypeRef", (PyObject *)&CFTypeRef_Type); + /* Backward-compatible name */ + Py_INCREF(&CFTypeRef_Type); + PyModule_AddObject(m, "CFTypeRefType", (PyObject *)&CFTypeRef_Type); + CFArrayRef_Type.ob_type = &PyType_Type; + CFArrayRef_Type.tp_base = &CFTypeRef_Type; + if (PyType_Ready(&CFArrayRef_Type) < 0) return; + Py_INCREF(&CFArrayRef_Type); + PyModule_AddObject(m, "CFArrayRef", (PyObject *)&CFArrayRef_Type); + /* Backward-compatible name */ + Py_INCREF(&CFArrayRef_Type); + PyModule_AddObject(m, "CFArrayRefType", (PyObject *)&CFArrayRef_Type); + CFMutableArrayRef_Type.ob_type = &PyType_Type; + CFMutableArrayRef_Type.tp_base = &CFArrayRef_Type; + if (PyType_Ready(&CFMutableArrayRef_Type) < 0) return; + Py_INCREF(&CFMutableArrayRef_Type); + PyModule_AddObject(m, "CFMutableArrayRef", (PyObject *)&CFMutableArrayRef_Type); + /* Backward-compatible name */ + Py_INCREF(&CFMutableArrayRef_Type); + PyModule_AddObject(m, "CFMutableArrayRefType", (PyObject *)&CFMutableArrayRef_Type); + CFDictionaryRef_Type.ob_type = &PyType_Type; + CFDictionaryRef_Type.tp_base = &CFTypeRef_Type; + if (PyType_Ready(&CFDictionaryRef_Type) < 0) return; + Py_INCREF(&CFDictionaryRef_Type); + PyModule_AddObject(m, "CFDictionaryRef", (PyObject *)&CFDictionaryRef_Type); + /* Backward-compatible name */ + Py_INCREF(&CFDictionaryRef_Type); + PyModule_AddObject(m, "CFDictionaryRefType", (PyObject *)&CFDictionaryRef_Type); + CFMutableDictionaryRef_Type.ob_type = &PyType_Type; + CFMutableDictionaryRef_Type.tp_base = &CFDictionaryRef_Type; + if (PyType_Ready(&CFMutableDictionaryRef_Type) < 0) return; + Py_INCREF(&CFMutableDictionaryRef_Type); + PyModule_AddObject(m, "CFMutableDictionaryRef", (PyObject *)&CFMutableDictionaryRef_Type); + /* Backward-compatible name */ + Py_INCREF(&CFMutableDictionaryRef_Type); + PyModule_AddObject(m, "CFMutableDictionaryRefType", (PyObject *)&CFMutableDictionaryRef_Type); + CFDataRef_Type.ob_type = &PyType_Type; + CFDataRef_Type.tp_base = &CFTypeRef_Type; + if (PyType_Ready(&CFDataRef_Type) < 0) return; + Py_INCREF(&CFDataRef_Type); + PyModule_AddObject(m, "CFDataRef", (PyObject *)&CFDataRef_Type); + /* Backward-compatible name */ + Py_INCREF(&CFDataRef_Type); + PyModule_AddObject(m, "CFDataRefType", (PyObject *)&CFDataRef_Type); + CFMutableDataRef_Type.ob_type = &PyType_Type; + CFMutableDataRef_Type.tp_base = &CFDataRef_Type; + if (PyType_Ready(&CFMutableDataRef_Type) < 0) return; + Py_INCREF(&CFMutableDataRef_Type); + PyModule_AddObject(m, "CFMutableDataRef", (PyObject *)&CFMutableDataRef_Type); + /* Backward-compatible name */ + Py_INCREF(&CFMutableDataRef_Type); + PyModule_AddObject(m, "CFMutableDataRefType", (PyObject *)&CFMutableDataRef_Type); + CFStringRef_Type.ob_type = &PyType_Type; + CFStringRef_Type.tp_base = &CFTypeRef_Type; + if (PyType_Ready(&CFStringRef_Type) < 0) return; + Py_INCREF(&CFStringRef_Type); + PyModule_AddObject(m, "CFStringRef", (PyObject *)&CFStringRef_Type); + /* Backward-compatible name */ + Py_INCREF(&CFStringRef_Type); + PyModule_AddObject(m, "CFStringRefType", (PyObject *)&CFStringRef_Type); + CFMutableStringRef_Type.ob_type = &PyType_Type; + CFMutableStringRef_Type.tp_base = &CFStringRef_Type; + if (PyType_Ready(&CFMutableStringRef_Type) < 0) return; + Py_INCREF(&CFMutableStringRef_Type); + PyModule_AddObject(m, "CFMutableStringRef", (PyObject *)&CFMutableStringRef_Type); + /* Backward-compatible name */ + Py_INCREF(&CFMutableStringRef_Type); + PyModule_AddObject(m, "CFMutableStringRefType", (PyObject *)&CFMutableStringRef_Type); + CFURLRef_Type.ob_type = &PyType_Type; + CFURLRef_Type.tp_base = &CFTypeRef_Type; + if (PyType_Ready(&CFURLRef_Type) < 0) return; + Py_INCREF(&CFURLRef_Type); + PyModule_AddObject(m, "CFURLRef", (PyObject *)&CFURLRef_Type); + /* Backward-compatible name */ + Py_INCREF(&CFURLRef_Type); + PyModule_AddObject(m, "CFURLRefType", (PyObject *)&CFURLRef_Type); + +#define _STRINGCONST(name) PyModule_AddObject(m, #name, CFStringRefObj_New(name)) + _STRINGCONST(kCFPreferencesAnyApplication); + _STRINGCONST(kCFPreferencesCurrentApplication); + _STRINGCONST(kCFPreferencesAnyHost); + _STRINGCONST(kCFPreferencesCurrentHost); + _STRINGCONST(kCFPreferencesAnyUser); + _STRINGCONST(kCFPreferencesCurrentUser); + + + +} + +/* ========================= End module _CF ========================= */ +