source: python/trunk/Mac/Modules/cf/_CFmodule.c

Last change on this file was 391, checked in by dmik, 11 years ago

python: Merge vendor 2.7.6 to trunk.
  • Property svn:eol-style set to native
File size: 165.5 KB
Line 
1
2/* =========================== Module _CF =========================== */
3
4#include "Python.h"
5
6
7
8#include "pymactoolbox.h"
9
10/* Macro to test whether a weak-loaded CFM function exists */
11#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
12 PyErr_SetString(PyExc_NotImplementedError, \
13 "Not available in this shared library/OS version"); \
14 return NULL; \
15 }} while(0)
16
17
18#include <CoreServices/CoreServices.h>
19
20#include "pycfbridge.h"
21
22#ifdef USE_TOOLBOX_OBJECT_GLUE
23extern PyObject *_CFObj_New(CFTypeRef);
24extern int _CFObj_Convert(PyObject *, CFTypeRef *);
25#define CFObj_New _CFObj_New
26#define CFObj_Convert _CFObj_Convert
27
28extern PyObject *_CFTypeRefObj_New(CFTypeRef);
29extern int _CFTypeRefObj_Convert(PyObject *, CFTypeRef *);
30#define CFTypeRefObj_New _CFTypeRefObj_New
31#define CFTypeRefObj_Convert _CFTypeRefObj_Convert
32
33extern PyObject *_CFStringRefObj_New(CFStringRef);
34extern int _CFStringRefObj_Convert(PyObject *, CFStringRef *);
35#define CFStringRefObj_New _CFStringRefObj_New
36#define CFStringRefObj_Convert _CFStringRefObj_Convert
37
38extern PyObject *_CFMutableStringRefObj_New(CFMutableStringRef);
39extern int _CFMutableStringRefObj_Convert(PyObject *, CFMutableStringRef *);
40#define CFMutableStringRefObj_New _CFMutableStringRefObj_New
41#define CFMutableStringRefObj_Convert _CFMutableStringRefObj_Convert
42
43extern PyObject *_CFArrayRefObj_New(CFArrayRef);
44extern int _CFArrayRefObj_Convert(PyObject *, CFArrayRef *);
45#define CFArrayRefObj_New _CFArrayRefObj_New
46#define CFArrayRefObj_Convert _CFArrayRefObj_Convert
47
48extern PyObject *_CFMutableArrayRefObj_New(CFMutableArrayRef);
49extern int _CFMutableArrayRefObj_Convert(PyObject *, CFMutableArrayRef *);
50#define CFMutableArrayRefObj_New _CFMutableArrayRefObj_New
51#define CFMutableArrayRefObj_Convert _CFMutableArrayRefObj_Convert
52
53extern PyObject *_CFDataRefObj_New(CFDataRef);
54extern int _CFDataRefObj_Convert(PyObject *, CFDataRef *);
55#define CFDataRefObj_New _CFDataRefObj_New
56#define CFDataRefObj_Convert _CFDataRefObj_Convert
57
58extern PyObject *_CFMutableDataRefObj_New(CFMutableDataRef);
59extern int _CFMutableDataRefObj_Convert(PyObject *, CFMutableDataRef *);
60#define CFMutableDataRefObj_New _CFMutableDataRefObj_New
61#define CFMutableDataRefObj_Convert _CFMutableDataRefObj_Convert
62
63extern PyObject *_CFDictionaryRefObj_New(CFDictionaryRef);
64extern int _CFDictionaryRefObj_Convert(PyObject *, CFDictionaryRef *);
65#define CFDictionaryRefObj_New _CFDictionaryRefObj_New
66#define CFDictionaryRefObj_Convert _CFDictionaryRefObj_Convert
67
68extern PyObject *_CFMutableDictionaryRefObj_New(CFMutableDictionaryRef);
69extern int _CFMutableDictionaryRefObj_Convert(PyObject *, CFMutableDictionaryRef *);
70#define CFMutableDictionaryRefObj_New _CFMutableDictionaryRefObj_New
71#define CFMutableDictionaryRefObj_Convert _CFMutableDictionaryRefObj_Convert
72
73extern PyObject *_CFURLRefObj_New(CFURLRef);
74extern int _CFURLRefObj_Convert(PyObject *, CFURLRef *);
75extern int _OptionalCFURLRefObj_Convert(PyObject *, CFURLRef *);
76#define CFURLRefObj_New _CFURLRefObj_New
77#define CFURLRefObj_Convert _CFURLRefObj_Convert
78#define OptionalCFURLRefObj_Convert _OptionalCFURLRefObj_Convert
79#endif
80
81/*
82** Parse/generate CFRange records
83*/
84PyObject *CFRange_New(CFRange *itself)
85{
86
87 return Py_BuildValue("ll", (long)itself->location, (long)itself->length);
88}
89
90int
91CFRange_Convert(PyObject *v, CFRange *p_itself)
92{
93 long location, length;
94
95 if( !PyArg_ParseTuple(v, "ll", &location, &length) )
96 return 0;
97 p_itself->location = (CFIndex)location;
98 p_itself->length = (CFIndex)length;
99 return 1;
100}
101
102/* Optional CFURL argument or None (passed as NULL) */
103int
104OptionalCFURLRefObj_Convert(PyObject *v, CFURLRef *p_itself)
105{
106 if ( v == Py_None ) {
107 p_itself = NULL;
108 return 1;
109 }
110 return CFURLRefObj_Convert(v, p_itself);
111}
112
113static PyObject *CF_Error;
114
115/* --------------------- Object type CFTypeRef ---------------------- */
116
117PyTypeObject CFTypeRef_Type;
118
119#define CFTypeRefObj_Check(x) ((x)->ob_type == &CFTypeRef_Type || PyObject_TypeCheck((x), &CFTypeRef_Type))
120
121typedef struct CFTypeRefObject {
122 PyObject_HEAD
123 CFTypeRef ob_itself;
124 void (*ob_freeit)(CFTypeRef ptr);
125} CFTypeRefObject;
126
127PyObject *CFTypeRefObj_New(CFTypeRef itself)
128{
129 CFTypeRefObject *it;
130 if (itself == NULL)
131 {
132 PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL");
133 return NULL;
134 }
135 it = PyObject_NEW(CFTypeRefObject, &CFTypeRef_Type);
136 if (it == NULL) return NULL;
137 it->ob_itself = itself;
138 it->ob_freeit = CFRelease;
139 return (PyObject *)it;
140}
141
142int CFTypeRefObj_Convert(PyObject *v, CFTypeRef *p_itself)
143{
144
145 if (v == Py_None) { *p_itself = NULL; return 1; }
146 /* Check for other CF objects here */
147
148 if (!CFTypeRefObj_Check(v))
149 {
150 PyErr_SetString(PyExc_TypeError, "CFTypeRef required");
151 return 0;
152 }
153 *p_itself = ((CFTypeRefObject *)v)->ob_itself;
154 return 1;
155}
156
157static void CFTypeRefObj_dealloc(CFTypeRefObject *self)
158{
159 if (self->ob_freeit && self->ob_itself)
160 {
161 self->ob_freeit((CFTypeRef)self->ob_itself);
162 self->ob_itself = NULL;
163 }
164 self->ob_type->tp_free((PyObject *)self);
165}
166
167static PyObject *CFTypeRefObj_CFGetTypeID(CFTypeRefObject *_self, PyObject *_args)
168{
169 PyObject *_res = NULL;
170 CFTypeID _rv;
171#ifndef CFGetTypeID
172 PyMac_PRECHECK(CFGetTypeID);
173#endif
174 if (!PyArg_ParseTuple(_args, ""))
175 return NULL;
176 _rv = CFGetTypeID(_self->ob_itself);
177 _res = Py_BuildValue("l",
178 _rv);
179 return _res;
180}
181
182static PyObject *CFTypeRefObj_CFRetain(CFTypeRefObject *_self, PyObject *_args)
183{
184 PyObject *_res = NULL;
185 CFTypeRef _rv;
186#ifndef CFRetain
187 PyMac_PRECHECK(CFRetain);
188#endif
189 if (!PyArg_ParseTuple(_args, ""))
190 return NULL;
191 _rv = CFRetain(_self->ob_itself);
192 _res = Py_BuildValue("O&",
193 CFTypeRefObj_New, _rv);
194 return _res;
195}
196
197static PyObject *CFTypeRefObj_CFRelease(CFTypeRefObject *_self, PyObject *_args)
198{
199 PyObject *_res = NULL;
200#ifndef CFRelease
201 PyMac_PRECHECK(CFRelease);
202#endif
203 if (!PyArg_ParseTuple(_args, ""))
204 return NULL;
205 CFRelease(_self->ob_itself);
206 Py_INCREF(Py_None);
207 _res = Py_None;
208 return _res;
209}
210
211static PyObject *CFTypeRefObj_CFGetRetainCount(CFTypeRefObject *_self, PyObject *_args)
212{
213 PyObject *_res = NULL;
214 CFIndex _rv;
215#ifndef CFGetRetainCount
216 PyMac_PRECHECK(CFGetRetainCount);
217#endif
218 if (!PyArg_ParseTuple(_args, ""))
219 return NULL;
220 _rv = CFGetRetainCount(_self->ob_itself);
221 _res = Py_BuildValue("l",
222 _rv);
223 return _res;
224}
225
226static PyObject *CFTypeRefObj_CFEqual(CFTypeRefObject *_self, PyObject *_args)
227{
228 PyObject *_res = NULL;
229 Boolean _rv;
230 CFTypeRef cf2;
231#ifndef CFEqual
232 PyMac_PRECHECK(CFEqual);
233#endif
234 if (!PyArg_ParseTuple(_args, "O&",
235 CFTypeRefObj_Convert, &cf2))
236 return NULL;
237 _rv = CFEqual(_self->ob_itself,
238 cf2);
239 _res = Py_BuildValue("l",
240 _rv);
241 return _res;
242}
243
244static PyObject *CFTypeRefObj_CFHash(CFTypeRefObject *_self, PyObject *_args)
245{
246 PyObject *_res = NULL;
247 CFHashCode _rv;
248#ifndef CFHash
249 PyMac_PRECHECK(CFHash);
250#endif
251 if (!PyArg_ParseTuple(_args, ""))
252 return NULL;
253 _rv = CFHash(_self->ob_itself);
254 _res = Py_BuildValue("l",
255 _rv);
256 return _res;
257}
258
259static PyObject *CFTypeRefObj_CFCopyDescription(CFTypeRefObject *_self, PyObject *_args)
260{
261 PyObject *_res = NULL;
262 CFStringRef _rv;
263#ifndef CFCopyDescription
264 PyMac_PRECHECK(CFCopyDescription);
265#endif
266 if (!PyArg_ParseTuple(_args, ""))
267 return NULL;
268 _rv = CFCopyDescription(_self->ob_itself);
269 _res = Py_BuildValue("O&",
270 CFStringRefObj_New, _rv);
271 return _res;
272}
273
274static PyObject *CFTypeRefObj_CFPropertyListCreateXMLData(CFTypeRefObject *_self, PyObject *_args)
275{
276 PyObject *_res = NULL;
277 CFDataRef _rv;
278 if (!PyArg_ParseTuple(_args, ""))
279 return NULL;
280 _rv = CFPropertyListCreateXMLData((CFAllocatorRef)NULL,
281 _self->ob_itself);
282 _res = Py_BuildValue("O&",
283 CFDataRefObj_New, _rv);
284 return _res;
285}
286
287static PyObject *CFTypeRefObj_CFPropertyListCreateDeepCopy(CFTypeRefObject *_self, PyObject *_args)
288{
289 PyObject *_res = NULL;
290 CFTypeRef _rv;
291 CFOptionFlags mutabilityOption;
292 if (!PyArg_ParseTuple(_args, "l",
293 &mutabilityOption))
294 return NULL;
295 _rv = CFPropertyListCreateDeepCopy((CFAllocatorRef)NULL,
296 _self->ob_itself,
297 mutabilityOption);
298 _res = Py_BuildValue("O&",
299 CFTypeRefObj_New, _rv);
300 return _res;
301}
302
303static PyObject *CFTypeRefObj_CFShow(CFTypeRefObject *_self, PyObject *_args)
304{
305 PyObject *_res = NULL;
306#ifndef CFShow
307 PyMac_PRECHECK(CFShow);
308#endif
309 if (!PyArg_ParseTuple(_args, ""))
310 return NULL;
311 CFShow(_self->ob_itself);
312 Py_INCREF(Py_None);
313 _res = Py_None;
314 return _res;
315}
316
317static PyObject *CFTypeRefObj_CFPropertyListCreateFromXMLData(CFTypeRefObject *_self, PyObject *_args)
318{
319 PyObject *_res = NULL;
320
321 CFTypeRef _rv;
322 CFOptionFlags mutabilityOption;
323 CFStringRef errorString;
324 if (!PyArg_ParseTuple(_args, "l",
325 &mutabilityOption))
326 return NULL;
327 _rv = CFPropertyListCreateFromXMLData((CFAllocatorRef)NULL,
328 _self->ob_itself,
329 mutabilityOption,
330 &errorString);
331 if (errorString)
332 CFRelease(errorString);
333 if (_rv == NULL) {
334 PyErr_SetString(PyExc_RuntimeError, "Parse error in XML data");
335 return NULL;
336 }
337 _res = Py_BuildValue("O&",
338 CFTypeRefObj_New, _rv);
339 return _res;
340
341}
342
343static PyObject *CFTypeRefObj_toPython(CFTypeRefObject *_self, PyObject *_args)
344{
345 PyObject *_res = NULL;
346
347 _res = PyCF_CF2Python(_self->ob_itself);
348 return _res;
349
350}
351
352static PyMethodDef CFTypeRefObj_methods[] = {
353 {"CFGetTypeID", (PyCFunction)CFTypeRefObj_CFGetTypeID, 1,
354 PyDoc_STR("() -> (CFTypeID _rv)")},
355 {"CFRetain", (PyCFunction)CFTypeRefObj_CFRetain, 1,
356 PyDoc_STR("() -> (CFTypeRef _rv)")},
357 {"CFRelease", (PyCFunction)CFTypeRefObj_CFRelease, 1,
358 PyDoc_STR("() -> None")},
359 {"CFGetRetainCount", (PyCFunction)CFTypeRefObj_CFGetRetainCount, 1,
360 PyDoc_STR("() -> (CFIndex _rv)")},
361 {"CFEqual", (PyCFunction)CFTypeRefObj_CFEqual, 1,
362 PyDoc_STR("(CFTypeRef cf2) -> (Boolean _rv)")},
363 {"CFHash", (PyCFunction)CFTypeRefObj_CFHash, 1,
364 PyDoc_STR("() -> (CFHashCode _rv)")},
365 {"CFCopyDescription", (PyCFunction)CFTypeRefObj_CFCopyDescription, 1,
366 PyDoc_STR("() -> (CFStringRef _rv)")},
367 {"CFPropertyListCreateXMLData", (PyCFunction)CFTypeRefObj_CFPropertyListCreateXMLData, 1,
368 PyDoc_STR("() -> (CFDataRef _rv)")},
369 {"CFPropertyListCreateDeepCopy", (PyCFunction)CFTypeRefObj_CFPropertyListCreateDeepCopy, 1,
370 PyDoc_STR("(CFOptionFlags mutabilityOption) -> (CFTypeRef _rv)")},
371 {"CFShow", (PyCFunction)CFTypeRefObj_CFShow, 1,
372 PyDoc_STR("() -> None")},
373 {"CFPropertyListCreateFromXMLData", (PyCFunction)CFTypeRefObj_CFPropertyListCreateFromXMLData, 1,
374 PyDoc_STR("(CFOptionFlags mutabilityOption) -> (CFTypeRefObj)")},
375 {"toPython", (PyCFunction)CFTypeRefObj_toPython, 1,
376 PyDoc_STR("() -> (python_object)")},
377 {NULL, NULL, 0}
378};
379
380#define CFTypeRefObj_getsetlist NULL
381
382
383static int CFTypeRefObj_compare(CFTypeRefObject *self, CFTypeRefObject *other)
384{
385 /* XXXX Or should we use CFEqual?? */
386 if ( self->ob_itself > other->ob_itself ) return 1;
387 if ( self->ob_itself < other->ob_itself ) return -1;
388 return 0;
389}
390
391static PyObject * CFTypeRefObj_repr(CFTypeRefObject *self)
392{
393 char buf[100];
394 sprintf(buf, "<CFTypeRef type-%d object at 0x%8.8x for 0x%8.8x>", (int)CFGetTypeID(self->ob_itself), (unsigned)self, (unsigned)self->ob_itself);
395 return PyString_FromString(buf);
396}
397
398static int CFTypeRefObj_hash(CFTypeRefObject *self)
399{
400 /* XXXX Or should we use CFHash?? */
401 return (int)self->ob_itself;
402}
403static int CFTypeRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)
404{
405 CFTypeRef itself;
406 char *kw[] = {"itself", 0};
407
408 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself))
409 {
410 ((CFTypeRefObject *)_self)->ob_itself = itself;
411 return 0;
412 }
413 return -1;
414}
415
416#define CFTypeRefObj_tp_alloc PyType_GenericAlloc
417
418static PyObject *CFTypeRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
419{
420 PyObject *self;
421 if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
422 ((CFTypeRefObject *)self)->ob_itself = NULL;
423 ((CFTypeRefObject *)self)->ob_freeit = CFRelease;
424 return self;
425}
426
427#define CFTypeRefObj_tp_free PyObject_Del
428
429
430PyTypeObject CFTypeRef_Type = {
431 PyObject_HEAD_INIT(NULL)
432 0, /*ob_size*/
433 "_CF.CFTypeRef", /*tp_name*/
434 sizeof(CFTypeRefObject), /*tp_basicsize*/
435 0, /*tp_itemsize*/
436 /* methods */
437 (destructor) CFTypeRefObj_dealloc, /*tp_dealloc*/
438 0, /*tp_print*/
439 (getattrfunc)0, /*tp_getattr*/
440 (setattrfunc)0, /*tp_setattr*/
441 (cmpfunc) CFTypeRefObj_compare, /*tp_compare*/
442 (reprfunc) CFTypeRefObj_repr, /*tp_repr*/
443 (PyNumberMethods *)0, /* tp_as_number */
444 (PySequenceMethods *)0, /* tp_as_sequence */
445 (PyMappingMethods *)0, /* tp_as_mapping */
446 (hashfunc) CFTypeRefObj_hash, /*tp_hash*/
447 0, /*tp_call*/
448 0, /*tp_str*/
449 PyObject_GenericGetAttr, /*tp_getattro*/
450 PyObject_GenericSetAttr, /*tp_setattro */
451 0, /*tp_as_buffer*/
452 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
453 0, /*tp_doc*/
454 0, /*tp_traverse*/
455 0, /*tp_clear*/
456 0, /*tp_richcompare*/
457 0, /*tp_weaklistoffset*/
458 0, /*tp_iter*/
459 0, /*tp_iternext*/
460 CFTypeRefObj_methods, /* tp_methods */
461 0, /*tp_members*/
462 CFTypeRefObj_getsetlist, /*tp_getset*/
463 0, /*tp_base*/
464 0, /*tp_dict*/
465 0, /*tp_descr_get*/
466 0, /*tp_descr_set*/
467 0, /*tp_dictoffset*/
468 CFTypeRefObj_tp_init, /* tp_init */
469 CFTypeRefObj_tp_alloc, /* tp_alloc */
470 CFTypeRefObj_tp_new, /* tp_new */
471 CFTypeRefObj_tp_free, /* tp_free */
472};
473
474/* ------------------- End object type CFTypeRef -------------------- */
475
476
477/* --------------------- Object type CFArrayRef --------------------- */
478
479PyTypeObject CFArrayRef_Type;
480
481#define CFArrayRefObj_Check(x) ((x)->ob_type == &CFArrayRef_Type || PyObject_TypeCheck((x), &CFArrayRef_Type))
482
483typedef struct CFArrayRefObject {
484 PyObject_HEAD
485 CFArrayRef ob_itself;
486 void (*ob_freeit)(CFTypeRef ptr);
487} CFArrayRefObject;
488
489PyObject *CFArrayRefObj_New(CFArrayRef itself)
490{
491 CFArrayRefObject *it;
492 if (itself == NULL)
493 {
494 PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL");
495 return NULL;
496 }
497 it = PyObject_NEW(CFArrayRefObject, &CFArrayRef_Type);
498 if (it == NULL) return NULL;
499 /* XXXX Should we tp_init or tp_new our basetype? */
500 it->ob_itself = itself;
501 it->ob_freeit = CFRelease;
502 return (PyObject *)it;
503}
504
505int CFArrayRefObj_Convert(PyObject *v, CFArrayRef *p_itself)
506{
507
508 if (v == Py_None) { *p_itself = NULL; return 1; }
509 /* Check for other CF objects here */
510
511 if (!CFArrayRefObj_Check(v))
512 {
513 PyErr_SetString(PyExc_TypeError, "CFArrayRef required");
514 return 0;
515 }
516 *p_itself = ((CFArrayRefObject *)v)->ob_itself;
517 return 1;
518}
519
520static void CFArrayRefObj_dealloc(CFArrayRefObject *self)
521{
522 if (self->ob_freeit && self->ob_itself)
523 {
524 self->ob_freeit((CFTypeRef)self->ob_itself);
525 self->ob_itself = NULL;
526 }
527 CFTypeRef_Type.tp_dealloc((PyObject *)self);
528}
529
530static PyObject *CFArrayRefObj_CFArrayCreateCopy(CFArrayRefObject *_self, PyObject *_args)
531{
532 PyObject *_res = NULL;
533 CFArrayRef _rv;
534 if (!PyArg_ParseTuple(_args, ""))
535 return NULL;
536 _rv = CFArrayCreateCopy((CFAllocatorRef)NULL,
537 _self->ob_itself);
538 _res = Py_BuildValue("O&",
539 CFArrayRefObj_New, _rv);
540 return _res;
541}
542
543static PyObject *CFArrayRefObj_CFArrayGetCount(CFArrayRefObject *_self, PyObject *_args)
544{
545 PyObject *_res = NULL;
546 CFIndex _rv;
547#ifndef CFArrayGetCount
548 PyMac_PRECHECK(CFArrayGetCount);
549#endif
550 if (!PyArg_ParseTuple(_args, ""))
551 return NULL;
552 _rv = CFArrayGetCount(_self->ob_itself);
553 _res = Py_BuildValue("l",
554 _rv);
555 return _res;
556}
557
558static PyObject *CFArrayRefObj_CFStringCreateByCombiningStrings(CFArrayRefObject *_self, PyObject *_args)
559{
560 PyObject *_res = NULL;
561 CFStringRef _rv;
562 CFStringRef separatorString;
563 if (!PyArg_ParseTuple(_args, "O&",
564 CFStringRefObj_Convert, &separatorString))
565 return NULL;
566 _rv = CFStringCreateByCombiningStrings((CFAllocatorRef)NULL,
567 _self->ob_itself,
568 separatorString);
569 _res = Py_BuildValue("O&",
570 CFStringRefObj_New, _rv);
571 return _res;
572}
573
574static PyMethodDef CFArrayRefObj_methods[] = {
575 {"CFArrayCreateCopy", (PyCFunction)CFArrayRefObj_CFArrayCreateCopy, 1,
576 PyDoc_STR("() -> (CFArrayRef _rv)")},
577 {"CFArrayGetCount", (PyCFunction)CFArrayRefObj_CFArrayGetCount, 1,
578 PyDoc_STR("() -> (CFIndex _rv)")},
579 {"CFStringCreateByCombiningStrings", (PyCFunction)CFArrayRefObj_CFStringCreateByCombiningStrings, 1,
580 PyDoc_STR("(CFStringRef separatorString) -> (CFStringRef _rv)")},
581 {NULL, NULL, 0}
582};
583
584#define CFArrayRefObj_getsetlist NULL
585
586
587static int CFArrayRefObj_compare(CFArrayRefObject *self, CFArrayRefObject *other)
588{
589 /* XXXX Or should we use CFEqual?? */
590 if ( self->ob_itself > other->ob_itself ) return 1;
591 if ( self->ob_itself < other->ob_itself ) return -1;
592 return 0;
593}
594
595static PyObject * CFArrayRefObj_repr(CFArrayRefObject *self)
596{
597 char buf[100];
598 sprintf(buf, "<CFArrayRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
599 return PyString_FromString(buf);
600}
601
602static int CFArrayRefObj_hash(CFArrayRefObject *self)
603{
604 /* XXXX Or should we use CFHash?? */
605 return (int)self->ob_itself;
606}
607static int CFArrayRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)
608{
609 CFArrayRef itself;
610 char *kw[] = {"itself", 0};
611
612 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFArrayRefObj_Convert, &itself))
613 {
614 ((CFArrayRefObject *)_self)->ob_itself = itself;
615 return 0;
616 }
617
618 /* Any CFTypeRef descendent is allowed as initializer too */
619 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself))
620 {
621 ((CFArrayRefObject *)_self)->ob_itself = itself;
622 return 0;
623 }
624 return -1;
625}
626
627#define CFArrayRefObj_tp_alloc PyType_GenericAlloc
628
629static PyObject *CFArrayRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
630{
631 PyObject *self;
632 if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
633 ((CFArrayRefObject *)self)->ob_itself = NULL;
634 ((CFArrayRefObject *)self)->ob_freeit = CFRelease;
635 return self;
636}
637
638#define CFArrayRefObj_tp_free PyObject_Del
639
640
641PyTypeObject CFArrayRef_Type = {
642 PyObject_HEAD_INIT(NULL)
643 0, /*ob_size*/
644 "_CF.CFArrayRef", /*tp_name*/
645 sizeof(CFArrayRefObject), /*tp_basicsize*/
646 0, /*tp_itemsize*/
647 /* methods */
648 (destructor) CFArrayRefObj_dealloc, /*tp_dealloc*/
649 0, /*tp_print*/
650 (getattrfunc)0, /*tp_getattr*/
651 (setattrfunc)0, /*tp_setattr*/
652 (cmpfunc) CFArrayRefObj_compare, /*tp_compare*/
653 (reprfunc) CFArrayRefObj_repr, /*tp_repr*/
654 (PyNumberMethods *)0, /* tp_as_number */
655 (PySequenceMethods *)0, /* tp_as_sequence */
656 (PyMappingMethods *)0, /* tp_as_mapping */
657 (hashfunc) CFArrayRefObj_hash, /*tp_hash*/
658 0, /*tp_call*/
659 0, /*tp_str*/
660 PyObject_GenericGetAttr, /*tp_getattro*/
661 PyObject_GenericSetAttr, /*tp_setattro */
662 0, /*tp_as_buffer*/
663 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
664 0, /*tp_doc*/
665 0, /*tp_traverse*/
666 0, /*tp_clear*/
667 0, /*tp_richcompare*/
668 0, /*tp_weaklistoffset*/
669 0, /*tp_iter*/
670 0, /*tp_iternext*/
671 CFArrayRefObj_methods, /* tp_methods */
672 0, /*tp_members*/
673 CFArrayRefObj_getsetlist, /*tp_getset*/
674 0, /*tp_base*/
675 0, /*tp_dict*/
676 0, /*tp_descr_get*/
677 0, /*tp_descr_set*/
678 0, /*tp_dictoffset*/
679 CFArrayRefObj_tp_init, /* tp_init */
680 CFArrayRefObj_tp_alloc, /* tp_alloc */
681 CFArrayRefObj_tp_new, /* tp_new */
682 CFArrayRefObj_tp_free, /* tp_free */
683};
684
685/* ------------------- End object type CFArrayRef ------------------- */
686
687
688/* ----------------- Object type CFMutableArrayRef ------------------ */
689
690PyTypeObject CFMutableArrayRef_Type;
691
692#define CFMutableArrayRefObj_Check(x) ((x)->ob_type == &CFMutableArrayRef_Type || PyObject_TypeCheck((x), &CFMutableArrayRef_Type))
693
694typedef struct CFMutableArrayRefObject {
695 PyObject_HEAD
696 CFMutableArrayRef ob_itself;
697 void (*ob_freeit)(CFTypeRef ptr);
698} CFMutableArrayRefObject;
699
700PyObject *CFMutableArrayRefObj_New(CFMutableArrayRef itself)
701{
702 CFMutableArrayRefObject *it;
703 if (itself == NULL)
704 {
705 PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL");
706 return NULL;
707 }
708 it = PyObject_NEW(CFMutableArrayRefObject, &CFMutableArrayRef_Type);
709 if (it == NULL) return NULL;
710 /* XXXX Should we tp_init or tp_new our basetype? */
711 it->ob_itself = itself;
712 it->ob_freeit = CFRelease;
713 return (PyObject *)it;
714}
715
716int CFMutableArrayRefObj_Convert(PyObject *v, CFMutableArrayRef *p_itself)
717{
718
719 if (v == Py_None) { *p_itself = NULL; return 1; }
720 /* Check for other CF objects here */
721
722 if (!CFMutableArrayRefObj_Check(v))
723 {
724 PyErr_SetString(PyExc_TypeError, "CFMutableArrayRef required");
725 return 0;
726 }
727 *p_itself = ((CFMutableArrayRefObject *)v)->ob_itself;
728 return 1;
729}
730
731static void CFMutableArrayRefObj_dealloc(CFMutableArrayRefObject *self)
732{
733 if (self->ob_freeit && self->ob_itself)
734 {
735 self->ob_freeit((CFTypeRef)self->ob_itself);
736 self->ob_itself = NULL;
737 }
738 CFArrayRef_Type.tp_dealloc((PyObject *)self);
739}
740
741static PyObject *CFMutableArrayRefObj_CFArrayRemoveValueAtIndex(CFMutableArrayRefObject *_self, PyObject *_args)
742{
743 PyObject *_res = NULL;
744 CFIndex idx;
745#ifndef CFArrayRemoveValueAtIndex
746 PyMac_PRECHECK(CFArrayRemoveValueAtIndex);
747#endif
748 if (!PyArg_ParseTuple(_args, "l",
749 &idx))
750 return NULL;
751 CFArrayRemoveValueAtIndex(_self->ob_itself,
752 idx);
753 Py_INCREF(Py_None);
754 _res = Py_None;
755 return _res;
756}
757
758static PyObject *CFMutableArrayRefObj_CFArrayRemoveAllValues(CFMutableArrayRefObject *_self, PyObject *_args)
759{
760 PyObject *_res = NULL;
761#ifndef CFArrayRemoveAllValues
762 PyMac_PRECHECK(CFArrayRemoveAllValues);
763#endif
764 if (!PyArg_ParseTuple(_args, ""))
765 return NULL;
766 CFArrayRemoveAllValues(_self->ob_itself);
767 Py_INCREF(Py_None);
768 _res = Py_None;
769 return _res;
770}
771
772static PyObject *CFMutableArrayRefObj_CFArrayExchangeValuesAtIndices(CFMutableArrayRefObject *_self, PyObject *_args)
773{
774 PyObject *_res = NULL;
775 CFIndex idx1;
776 CFIndex idx2;
777#ifndef CFArrayExchangeValuesAtIndices
778 PyMac_PRECHECK(CFArrayExchangeValuesAtIndices);
779#endif
780 if (!PyArg_ParseTuple(_args, "ll",
781 &idx1,
782 &idx2))
783 return NULL;
784 CFArrayExchangeValuesAtIndices(_self->ob_itself,
785 idx1,
786 idx2);
787 Py_INCREF(Py_None);
788 _res = Py_None;
789 return _res;
790}
791
792static PyObject *CFMutableArrayRefObj_CFArrayAppendArray(CFMutableArrayRefObject *_self, PyObject *_args)
793{
794 PyObject *_res = NULL;
795 CFArrayRef otherArray;
796 CFRange otherRange;
797#ifndef CFArrayAppendArray
798 PyMac_PRECHECK(CFArrayAppendArray);
799#endif
800 if (!PyArg_ParseTuple(_args, "O&O&",
801 CFArrayRefObj_Convert, &otherArray,
802 CFRange_Convert, &otherRange))
803 return NULL;
804 CFArrayAppendArray(_self->ob_itself,
805 otherArray,
806 otherRange);
807 Py_INCREF(Py_None);
808 _res = Py_None;
809 return _res;
810}
811
812static PyMethodDef CFMutableArrayRefObj_methods[] = {
813 {"CFArrayRemoveValueAtIndex", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveValueAtIndex, 1,
814 PyDoc_STR("(CFIndex idx) -> None")},
815 {"CFArrayRemoveAllValues", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveAllValues, 1,
816 PyDoc_STR("() -> None")},
817 {"CFArrayExchangeValuesAtIndices", (PyCFunction)CFMutableArrayRefObj_CFArrayExchangeValuesAtIndices, 1,
818 PyDoc_STR("(CFIndex idx1, CFIndex idx2) -> None")},
819 {"CFArrayAppendArray", (PyCFunction)CFMutableArrayRefObj_CFArrayAppendArray, 1,
820 PyDoc_STR("(CFArrayRef otherArray, CFRange otherRange) -> None")},
821 {NULL, NULL, 0}
822};
823
824#define CFMutableArrayRefObj_getsetlist NULL
825
826
827static int CFMutableArrayRefObj_compare(CFMutableArrayRefObject *self, CFMutableArrayRefObject *other)
828{
829 /* XXXX Or should we use CFEqual?? */
830 if ( self->ob_itself > other->ob_itself ) return 1;
831 if ( self->ob_itself < other->ob_itself ) return -1;
832 return 0;
833}
834
835static PyObject * CFMutableArrayRefObj_repr(CFMutableArrayRefObject *self)
836{
837 char buf[100];
838 sprintf(buf, "<CFMutableArrayRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
839 return PyString_FromString(buf);
840}
841
842static int CFMutableArrayRefObj_hash(CFMutableArrayRefObject *self)
843{
844 /* XXXX Or should we use CFHash?? */
845 return (int)self->ob_itself;
846}
847static int CFMutableArrayRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)
848{
849 CFMutableArrayRef itself;
850 char *kw[] = {"itself", 0};
851
852 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFMutableArrayRefObj_Convert, &itself))
853 {
854 ((CFMutableArrayRefObject *)_self)->ob_itself = itself;
855 return 0;
856 }
857
858 /* Any CFTypeRef descendent is allowed as initializer too */
859 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself))
860 {
861 ((CFMutableArrayRefObject *)_self)->ob_itself = itself;
862 return 0;
863 }
864 return -1;
865}
866
867#define CFMutableArrayRefObj_tp_alloc PyType_GenericAlloc
868
869static PyObject *CFMutableArrayRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
870{
871 PyObject *self;
872 if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
873 ((CFMutableArrayRefObject *)self)->ob_itself = NULL;
874 ((CFMutableArrayRefObject *)self)->ob_freeit = CFRelease;
875 return self;
876}
877
878#define CFMutableArrayRefObj_tp_free PyObject_Del
879
880
881PyTypeObject CFMutableArrayRef_Type = {
882 PyObject_HEAD_INIT(NULL)
883 0, /*ob_size*/
884 "_CF.CFMutableArrayRef", /*tp_name*/
885 sizeof(CFMutableArrayRefObject), /*tp_basicsize*/
886 0, /*tp_itemsize*/
887 /* methods */
888 (destructor) CFMutableArrayRefObj_dealloc, /*tp_dealloc*/
889 0, /*tp_print*/
890 (getattrfunc)0, /*tp_getattr*/
891 (setattrfunc)0, /*tp_setattr*/
892 (cmpfunc) CFMutableArrayRefObj_compare, /*tp_compare*/
893 (reprfunc) CFMutableArrayRefObj_repr, /*tp_repr*/
894 (PyNumberMethods *)0, /* tp_as_number */
895 (PySequenceMethods *)0, /* tp_as_sequence */
896 (PyMappingMethods *)0, /* tp_as_mapping */
897 (hashfunc) CFMutableArrayRefObj_hash, /*tp_hash*/
898 0, /*tp_call*/
899 0, /*tp_str*/
900 PyObject_GenericGetAttr, /*tp_getattro*/
901 PyObject_GenericSetAttr, /*tp_setattro */
902 0, /*tp_as_buffer*/
903 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
904 0, /*tp_doc*/
905 0, /*tp_traverse*/
906 0, /*tp_clear*/
907 0, /*tp_richcompare*/
908 0, /*tp_weaklistoffset*/
909 0, /*tp_iter*/
910 0, /*tp_iternext*/
911 CFMutableArrayRefObj_methods, /* tp_methods */
912 0, /*tp_members*/
913 CFMutableArrayRefObj_getsetlist, /*tp_getset*/
914 0, /*tp_base*/
915 0, /*tp_dict*/
916 0, /*tp_descr_get*/
917 0, /*tp_descr_set*/
918 0, /*tp_dictoffset*/
919 CFMutableArrayRefObj_tp_init, /* tp_init */
920 CFMutableArrayRefObj_tp_alloc, /* tp_alloc */
921 CFMutableArrayRefObj_tp_new, /* tp_new */
922 CFMutableArrayRefObj_tp_free, /* tp_free */
923};
924
925/* --------------- End object type CFMutableArrayRef ---------------- */
926
927
928/* ------------------ Object type CFDictionaryRef ------------------- */
929
930PyTypeObject CFDictionaryRef_Type;
931
932#define CFDictionaryRefObj_Check(x) ((x)->ob_type == &CFDictionaryRef_Type || PyObject_TypeCheck((x), &CFDictionaryRef_Type))
933
934typedef struct CFDictionaryRefObject {
935 PyObject_HEAD
936 CFDictionaryRef ob_itself;
937 void (*ob_freeit)(CFTypeRef ptr);
938} CFDictionaryRefObject;
939
940PyObject *CFDictionaryRefObj_New(CFDictionaryRef itself)
941{
942 CFDictionaryRefObject *it;
943 if (itself == NULL)
944 {
945 PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL");
946 return NULL;
947 }
948 it = PyObject_NEW(CFDictionaryRefObject, &CFDictionaryRef_Type);
949 if (it == NULL) return NULL;
950 /* XXXX Should we tp_init or tp_new our basetype? */
951 it->ob_itself = itself;
952 it->ob_freeit = CFRelease;
953 return (PyObject *)it;
954}
955
956int CFDictionaryRefObj_Convert(PyObject *v, CFDictionaryRef *p_itself)
957{
958
959 if (v == Py_None) { *p_itself = NULL; return 1; }
960 /* Check for other CF objects here */
961
962 if (!CFDictionaryRefObj_Check(v))
963 {
964 PyErr_SetString(PyExc_TypeError, "CFDictionaryRef required");
965 return 0;
966 }
967 *p_itself = ((CFDictionaryRefObject *)v)->ob_itself;
968 return 1;
969}
970
971static void CFDictionaryRefObj_dealloc(CFDictionaryRefObject *self)
972{
973 if (self->ob_freeit && self->ob_itself)
974 {
975 self->ob_freeit((CFTypeRef)self->ob_itself);
976 self->ob_itself = NULL;
977 }
978 CFTypeRef_Type.tp_dealloc((PyObject *)self);
979}
980
981static PyObject *CFDictionaryRefObj_CFDictionaryCreateCopy(CFDictionaryRefObject *_self, PyObject *_args)
982{
983 PyObject *_res = NULL;
984 CFDictionaryRef _rv;
985 if (!PyArg_ParseTuple(_args, ""))
986 return NULL;
987 _rv = CFDictionaryCreateCopy((CFAllocatorRef)NULL,
988 _self->ob_itself);
989 _res = Py_BuildValue("O&",
990 CFDictionaryRefObj_New, _rv);
991 return _res;
992}
993
994static PyObject *CFDictionaryRefObj_CFDictionaryGetCount(CFDictionaryRefObject *_self, PyObject *_args)
995{
996 PyObject *_res = NULL;
997 CFIndex _rv;
998#ifndef CFDictionaryGetCount
999 PyMac_PRECHECK(CFDictionaryGetCount);
1000#endif
1001 if (!PyArg_ParseTuple(_args, ""))
1002 return NULL;
1003 _rv = CFDictionaryGetCount(_self->ob_itself);
1004 _res = Py_BuildValue("l",
1005 _rv);
1006 return _res;
1007}
1008
1009static PyMethodDef CFDictionaryRefObj_methods[] = {
1010 {"CFDictionaryCreateCopy", (PyCFunction)CFDictionaryRefObj_CFDictionaryCreateCopy, 1,
1011 PyDoc_STR("() -> (CFDictionaryRef _rv)")},
1012 {"CFDictionaryGetCount", (PyCFunction)CFDictionaryRefObj_CFDictionaryGetCount, 1,
1013 PyDoc_STR("() -> (CFIndex _rv)")},
1014 {NULL, NULL, 0}
1015};
1016
1017#define CFDictionaryRefObj_getsetlist NULL
1018
1019
1020static int CFDictionaryRefObj_compare(CFDictionaryRefObject *self, CFDictionaryRefObject *other)
1021{
1022 /* XXXX Or should we use CFEqual?? */
1023 if ( self->ob_itself > other->ob_itself ) return 1;
1024 if ( self->ob_itself < other->ob_itself ) return -1;
1025 return 0;
1026}
1027
1028static PyObject * CFDictionaryRefObj_repr(CFDictionaryRefObject *self)
1029{
1030 char buf[100];
1031 sprintf(buf, "<CFDictionaryRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
1032 return PyString_FromString(buf);
1033}
1034
1035static int CFDictionaryRefObj_hash(CFDictionaryRefObject *self)
1036{
1037 /* XXXX Or should we use CFHash?? */
1038 return (int)self->ob_itself;
1039}
1040static int CFDictionaryRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)
1041{
1042 CFDictionaryRef itself;
1043 char *kw[] = {"itself", 0};
1044
1045 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFDictionaryRefObj_Convert, &itself))
1046 {
1047 ((CFDictionaryRefObject *)_self)->ob_itself = itself;
1048 return 0;
1049 }
1050
1051 /* Any CFTypeRef descendent is allowed as initializer too */
1052 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself))
1053 {
1054 ((CFDictionaryRefObject *)_self)->ob_itself = itself;
1055 return 0;
1056 }
1057 return -1;
1058}
1059
1060#define CFDictionaryRefObj_tp_alloc PyType_GenericAlloc
1061
1062static PyObject *CFDictionaryRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
1063{
1064 PyObject *self;
1065 if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
1066 ((CFDictionaryRefObject *)self)->ob_itself = NULL;
1067 ((CFDictionaryRefObject *)self)->ob_freeit = CFRelease;
1068 return self;
1069}
1070
1071#define CFDictionaryRefObj_tp_free PyObject_Del
1072
1073
1074PyTypeObject CFDictionaryRef_Type = {
1075 PyObject_HEAD_INIT(NULL)
1076 0, /*ob_size*/
1077 "_CF.CFDictionaryRef", /*tp_name*/
1078 sizeof(CFDictionaryRefObject), /*tp_basicsize*/
1079 0, /*tp_itemsize*/
1080 /* methods */
1081 (destructor) CFDictionaryRefObj_dealloc, /*tp_dealloc*/
1082 0, /*tp_print*/
1083 (getattrfunc)0, /*tp_getattr*/
1084 (setattrfunc)0, /*tp_setattr*/
1085 (cmpfunc) CFDictionaryRefObj_compare, /*tp_compare*/
1086 (reprfunc) CFDictionaryRefObj_repr, /*tp_repr*/
1087 (PyNumberMethods *)0, /* tp_as_number */
1088 (PySequenceMethods *)0, /* tp_as_sequence */
1089 (PyMappingMethods *)0, /* tp_as_mapping */
1090 (hashfunc) CFDictionaryRefObj_hash, /*tp_hash*/
1091 0, /*tp_call*/
1092 0, /*tp_str*/
1093 PyObject_GenericGetAttr, /*tp_getattro*/
1094 PyObject_GenericSetAttr, /*tp_setattro */
1095 0, /*tp_as_buffer*/
1096 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
1097 0, /*tp_doc*/
1098 0, /*tp_traverse*/
1099 0, /*tp_clear*/
1100 0, /*tp_richcompare*/
1101 0, /*tp_weaklistoffset*/
1102 0, /*tp_iter*/
1103 0, /*tp_iternext*/
1104 CFDictionaryRefObj_methods, /* tp_methods */
1105 0, /*tp_members*/
1106 CFDictionaryRefObj_getsetlist, /*tp_getset*/
1107 0, /*tp_base*/
1108 0, /*tp_dict*/
1109 0, /*tp_descr_get*/
1110 0, /*tp_descr_set*/
1111 0, /*tp_dictoffset*/
1112 CFDictionaryRefObj_tp_init, /* tp_init */
1113 CFDictionaryRefObj_tp_alloc, /* tp_alloc */
1114 CFDictionaryRefObj_tp_new, /* tp_new */
1115 CFDictionaryRefObj_tp_free, /* tp_free */
1116};
1117
1118/* ---------------- End object type CFDictionaryRef ----------------- */
1119
1120
1121/* --------------- Object type CFMutableDictionaryRef --------------- */
1122
1123PyTypeObject CFMutableDictionaryRef_Type;
1124
1125#define CFMutableDictionaryRefObj_Check(x) ((x)->ob_type == &CFMutableDictionaryRef_Type || PyObject_TypeCheck((x), &CFMutableDictionaryRef_Type))
1126
1127typedef struct CFMutableDictionaryRefObject {
1128 PyObject_HEAD
1129 CFMutableDictionaryRef ob_itself;
1130 void (*ob_freeit)(CFTypeRef ptr);
1131} CFMutableDictionaryRefObject;
1132
1133PyObject *CFMutableDictionaryRefObj_New(CFMutableDictionaryRef itself)
1134{
1135 CFMutableDictionaryRefObject *it;
1136 if (itself == NULL)
1137 {
1138 PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL");
1139 return NULL;
1140 }
1141 it = PyObject_NEW(CFMutableDictionaryRefObject, &CFMutableDictionaryRef_Type);
1142 if (it == NULL) return NULL;
1143 /* XXXX Should we tp_init or tp_new our basetype? */
1144 it->ob_itself = itself;
1145 it->ob_freeit = CFRelease;
1146 return (PyObject *)it;
1147}
1148
1149int CFMutableDictionaryRefObj_Convert(PyObject *v, CFMutableDictionaryRef *p_itself)
1150{
1151
1152 if (v == Py_None) { *p_itself = NULL; return 1; }
1153 /* Check for other CF objects here */
1154
1155 if (!CFMutableDictionaryRefObj_Check(v))
1156 {
1157 PyErr_SetString(PyExc_TypeError, "CFMutableDictionaryRef required");
1158 return 0;
1159 }
1160 *p_itself = ((CFMutableDictionaryRefObject *)v)->ob_itself;
1161 return 1;
1162}
1163
1164static void CFMutableDictionaryRefObj_dealloc(CFMutableDictionaryRefObject *self)
1165{
1166 if (self->ob_freeit && self->ob_itself)
1167 {
1168 self->ob_freeit((CFTypeRef)self->ob_itself);
1169 self->ob_itself = NULL;
1170 }
1171 CFDictionaryRef_Type.tp_dealloc((PyObject *)self);
1172}
1173
1174static PyObject *CFMutableDictionaryRefObj_CFDictionaryRemoveAllValues(CFMutableDictionaryRefObject *_self, PyObject *_args)
1175{
1176 PyObject *_res = NULL;
1177#ifndef CFDictionaryRemoveAllValues
1178 PyMac_PRECHECK(CFDictionaryRemoveAllValues);
1179#endif
1180 if (!PyArg_ParseTuple(_args, ""))
1181 return NULL;
1182 CFDictionaryRemoveAllValues(_self->ob_itself);
1183 Py_INCREF(Py_None);
1184 _res = Py_None;
1185 return _res;
1186}
1187
1188static PyMethodDef CFMutableDictionaryRefObj_methods[] = {
1189 {"CFDictionaryRemoveAllValues", (PyCFunction)CFMutableDictionaryRefObj_CFDictionaryRemoveAllValues, 1,
1190 PyDoc_STR("() -> None")},
1191 {NULL, NULL, 0}
1192};
1193
1194#define CFMutableDictionaryRefObj_getsetlist NULL
1195
1196
1197static int CFMutableDictionaryRefObj_compare(CFMutableDictionaryRefObject *self, CFMutableDictionaryRefObject *other)
1198{
1199 /* XXXX Or should we use CFEqual?? */
1200 if ( self->ob_itself > other->ob_itself ) return 1;
1201 if ( self->ob_itself < other->ob_itself ) return -1;
1202 return 0;
1203}
1204
1205static PyObject * CFMutableDictionaryRefObj_repr(CFMutableDictionaryRefObject *self)
1206{
1207 char buf[100];
1208 sprintf(buf, "<CFMutableDictionaryRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
1209 return PyString_FromString(buf);
1210}
1211
1212static int CFMutableDictionaryRefObj_hash(CFMutableDictionaryRefObject *self)
1213{
1214 /* XXXX Or should we use CFHash?? */
1215 return (int)self->ob_itself;
1216}
1217static int CFMutableDictionaryRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)
1218{
1219 CFMutableDictionaryRef itself;
1220 char *kw[] = {"itself", 0};
1221
1222 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFMutableDictionaryRefObj_Convert, &itself))
1223 {
1224 ((CFMutableDictionaryRefObject *)_self)->ob_itself = itself;
1225 return 0;
1226 }
1227
1228 /* Any CFTypeRef descendent is allowed as initializer too */
1229 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself))
1230 {
1231 ((CFMutableDictionaryRefObject *)_self)->ob_itself = itself;
1232 return 0;
1233 }
1234 return -1;
1235}
1236
1237#define CFMutableDictionaryRefObj_tp_alloc PyType_GenericAlloc
1238
1239static PyObject *CFMutableDictionaryRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
1240{
1241 PyObject *self;
1242 if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
1243 ((CFMutableDictionaryRefObject *)self)->ob_itself = NULL;
1244 ((CFMutableDictionaryRefObject *)self)->ob_freeit = CFRelease;
1245 return self;
1246}
1247
1248#define CFMutableDictionaryRefObj_tp_free PyObject_Del
1249
1250
1251PyTypeObject CFMutableDictionaryRef_Type = {
1252 PyObject_HEAD_INIT(NULL)
1253 0, /*ob_size*/
1254 "_CF.CFMutableDictionaryRef", /*tp_name*/
1255 sizeof(CFMutableDictionaryRefObject), /*tp_basicsize*/
1256 0, /*tp_itemsize*/
1257 /* methods */
1258 (destructor) CFMutableDictionaryRefObj_dealloc, /*tp_dealloc*/
1259 0, /*tp_print*/
1260 (getattrfunc)0, /*tp_getattr*/
1261 (setattrfunc)0, /*tp_setattr*/
1262 (cmpfunc) CFMutableDictionaryRefObj_compare, /*tp_compare*/
1263 (reprfunc) CFMutableDictionaryRefObj_repr, /*tp_repr*/
1264 (PyNumberMethods *)0, /* tp_as_number */
1265 (PySequenceMethods *)0, /* tp_as_sequence */
1266 (PyMappingMethods *)0, /* tp_as_mapping */
1267 (hashfunc) CFMutableDictionaryRefObj_hash, /*tp_hash*/
1268 0, /*tp_call*/
1269 0, /*tp_str*/
1270 PyObject_GenericGetAttr, /*tp_getattro*/
1271 PyObject_GenericSetAttr, /*tp_setattro */
1272 0, /*tp_as_buffer*/
1273 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
1274 0, /*tp_doc*/
1275 0, /*tp_traverse*/
1276 0, /*tp_clear*/
1277 0, /*tp_richcompare*/
1278 0, /*tp_weaklistoffset*/
1279 0, /*tp_iter*/
1280 0, /*tp_iternext*/
1281 CFMutableDictionaryRefObj_methods, /* tp_methods */
1282 0, /*tp_members*/
1283 CFMutableDictionaryRefObj_getsetlist, /*tp_getset*/
1284 0, /*tp_base*/
1285 0, /*tp_dict*/
1286 0, /*tp_descr_get*/
1287 0, /*tp_descr_set*/
1288 0, /*tp_dictoffset*/
1289 CFMutableDictionaryRefObj_tp_init, /* tp_init */
1290 CFMutableDictionaryRefObj_tp_alloc, /* tp_alloc */
1291 CFMutableDictionaryRefObj_tp_new, /* tp_new */
1292 CFMutableDictionaryRefObj_tp_free, /* tp_free */
1293};
1294
1295/* ------------- End object type CFMutableDictionaryRef ------------- */
1296
1297
1298/* --------------------- Object type CFDataRef ---------------------- */
1299
1300PyTypeObject CFDataRef_Type;
1301
1302#define CFDataRefObj_Check(x) ((x)->ob_type == &CFDataRef_Type || PyObject_TypeCheck((x), &CFDataRef_Type))
1303
1304typedef struct CFDataRefObject {
1305 PyObject_HEAD
1306 CFDataRef ob_itself;
1307 void (*ob_freeit)(CFTypeRef ptr);
1308} CFDataRefObject;
1309
1310PyObject *CFDataRefObj_New(CFDataRef itself)
1311{
1312 CFDataRefObject *it;
1313 if (itself == NULL)
1314 {
1315 PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL");
1316 return NULL;
1317 }
1318 it = PyObject_NEW(CFDataRefObject, &CFDataRef_Type);
1319 if (it == NULL) return NULL;
1320 /* XXXX Should we tp_init or tp_new our basetype? */
1321 it->ob_itself = itself;
1322 it->ob_freeit = CFRelease;
1323 return (PyObject *)it;
1324}
1325
1326int CFDataRefObj_Convert(PyObject *v, CFDataRef *p_itself)
1327{
1328
1329 if (v == Py_None) { *p_itself = NULL; return 1; }
1330 if (PyString_Check(v)) {
1331 char *cStr;
1332 Py_ssize_t cLen;
1333 if( PyString_AsStringAndSize(v, &cStr, &cLen) < 0 ) return 0;
1334 *p_itself = CFDataCreate((CFAllocatorRef)NULL, (unsigned char *)cStr, cLen);
1335 return 1;
1336 }
1337
1338 if (!CFDataRefObj_Check(v))
1339 {
1340 PyErr_SetString(PyExc_TypeError, "CFDataRef required");
1341 return 0;
1342 }
1343 *p_itself = ((CFDataRefObject *)v)->ob_itself;
1344 return 1;
1345}
1346
1347static void CFDataRefObj_dealloc(CFDataRefObject *self)
1348{
1349 if (self->ob_freeit && self->ob_itself)
1350 {
1351 self->ob_freeit((CFTypeRef)self->ob_itself);
1352 self->ob_itself = NULL;
1353 }
1354 CFTypeRef_Type.tp_dealloc((PyObject *)self);
1355}
1356
1357static PyObject *CFDataRefObj_CFDataCreateCopy(CFDataRefObject *_self, PyObject *_args)
1358{
1359 PyObject *_res = NULL;
1360 CFDataRef _rv;
1361 if (!PyArg_ParseTuple(_args, ""))
1362 return NULL;
1363 _rv = CFDataCreateCopy((CFAllocatorRef)NULL,
1364 _self->ob_itself);
1365 _res = Py_BuildValue("O&",
1366 CFDataRefObj_New, _rv);
1367 return _res;
1368}
1369
1370static PyObject *CFDataRefObj_CFDataGetLength(CFDataRefObject *_self, PyObject *_args)
1371{
1372 PyObject *_res = NULL;
1373 CFIndex _rv;
1374#ifndef CFDataGetLength
1375 PyMac_PRECHECK(CFDataGetLength);
1376#endif
1377 if (!PyArg_ParseTuple(_args, ""))
1378 return NULL;
1379 _rv = CFDataGetLength(_self->ob_itself);
1380 _res = Py_BuildValue("l",
1381 _rv);
1382 return _res;
1383}
1384
1385static PyObject *CFDataRefObj_CFStringCreateFromExternalRepresentation(CFDataRefObject *_self, PyObject *_args)
1386{
1387 PyObject *_res = NULL;
1388 CFStringRef _rv;
1389 CFStringEncoding encoding;
1390 if (!PyArg_ParseTuple(_args, "l",
1391 &encoding))
1392 return NULL;
1393 _rv = CFStringCreateFromExternalRepresentation((CFAllocatorRef)NULL,
1394 _self->ob_itself,
1395 encoding);
1396 _res = Py_BuildValue("O&",
1397 CFStringRefObj_New, _rv);
1398 return _res;
1399}
1400
1401static PyObject *CFDataRefObj_CFDataGetData(CFDataRefObject *_self, PyObject *_args)
1402{
1403 PyObject *_res = NULL;
1404
1405 int size = CFDataGetLength(_self->ob_itself);
1406 char *data = (char *)CFDataGetBytePtr(_self->ob_itself);
1407
1408 _res = (PyObject *)PyString_FromStringAndSize(data, size);
1409 return _res;
1410
1411}
1412
1413static PyMethodDef CFDataRefObj_methods[] = {
1414 {"CFDataCreateCopy", (PyCFunction)CFDataRefObj_CFDataCreateCopy, 1,
1415 PyDoc_STR("() -> (CFDataRef _rv)")},
1416 {"CFDataGetLength", (PyCFunction)CFDataRefObj_CFDataGetLength, 1,
1417 PyDoc_STR("() -> (CFIndex _rv)")},
1418 {"CFStringCreateFromExternalRepresentation", (PyCFunction)CFDataRefObj_CFStringCreateFromExternalRepresentation, 1,
1419 PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")},
1420 {"CFDataGetData", (PyCFunction)CFDataRefObj_CFDataGetData, 1,
1421 PyDoc_STR("() -> (string _rv)")},
1422 {NULL, NULL, 0}
1423};
1424
1425#define CFDataRefObj_getsetlist NULL
1426
1427
1428static int CFDataRefObj_compare(CFDataRefObject *self, CFDataRefObject *other)
1429{
1430 /* XXXX Or should we use CFEqual?? */
1431 if ( self->ob_itself > other->ob_itself ) return 1;
1432 if ( self->ob_itself < other->ob_itself ) return -1;
1433 return 0;
1434}
1435
1436static PyObject * CFDataRefObj_repr(CFDataRefObject *self)
1437{
1438 char buf[100];
1439 sprintf(buf, "<CFDataRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
1440 return PyString_FromString(buf);
1441}
1442
1443static int CFDataRefObj_hash(CFDataRefObject *self)
1444{
1445 /* XXXX Or should we use CFHash?? */
1446 return (int)self->ob_itself;
1447}
1448static int CFDataRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)
1449{
1450 CFDataRef itself;
1451 char *kw[] = {"itself", 0};
1452
1453 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFDataRefObj_Convert, &itself))
1454 {
1455 ((CFDataRefObject *)_self)->ob_itself = itself;
1456 return 0;
1457 }
1458
1459 /* Any CFTypeRef descendent is allowed as initializer too */
1460 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself))
1461 {
1462 ((CFDataRefObject *)_self)->ob_itself = itself;
1463 return 0;
1464 }
1465 return -1;
1466}
1467
1468#define CFDataRefObj_tp_alloc PyType_GenericAlloc
1469
1470static PyObject *CFDataRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
1471{
1472 PyObject *self;
1473 if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
1474 ((CFDataRefObject *)self)->ob_itself = NULL;
1475 ((CFDataRefObject *)self)->ob_freeit = CFRelease;
1476 return self;
1477}
1478
1479#define CFDataRefObj_tp_free PyObject_Del
1480
1481
1482PyTypeObject CFDataRef_Type = {
1483 PyObject_HEAD_INIT(NULL)
1484 0, /*ob_size*/
1485 "_CF.CFDataRef", /*tp_name*/
1486 sizeof(CFDataRefObject), /*tp_basicsize*/
1487 0, /*tp_itemsize*/
1488 /* methods */
1489 (destructor) CFDataRefObj_dealloc, /*tp_dealloc*/
1490 0, /*tp_print*/
1491 (getattrfunc)0, /*tp_getattr*/
1492 (setattrfunc)0, /*tp_setattr*/
1493 (cmpfunc) CFDataRefObj_compare, /*tp_compare*/
1494 (reprfunc) CFDataRefObj_repr, /*tp_repr*/
1495 (PyNumberMethods *)0, /* tp_as_number */
1496 (PySequenceMethods *)0, /* tp_as_sequence */
1497 (PyMappingMethods *)0, /* tp_as_mapping */
1498 (hashfunc) CFDataRefObj_hash, /*tp_hash*/
1499 0, /*tp_call*/
1500 0, /*tp_str*/
1501 PyObject_GenericGetAttr, /*tp_getattro*/
1502 PyObject_GenericSetAttr, /*tp_setattro */
1503 0, /*tp_as_buffer*/
1504 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
1505 0, /*tp_doc*/
1506 0, /*tp_traverse*/
1507 0, /*tp_clear*/
1508 0, /*tp_richcompare*/
1509 0, /*tp_weaklistoffset*/
1510 0, /*tp_iter*/
1511 0, /*tp_iternext*/
1512 CFDataRefObj_methods, /* tp_methods */
1513 0, /*tp_members*/
1514 CFDataRefObj_getsetlist, /*tp_getset*/
1515 0, /*tp_base*/
1516 0, /*tp_dict*/
1517 0, /*tp_descr_get*/
1518 0, /*tp_descr_set*/
1519 0, /*tp_dictoffset*/
1520 CFDataRefObj_tp_init, /* tp_init */
1521 CFDataRefObj_tp_alloc, /* tp_alloc */
1522 CFDataRefObj_tp_new, /* tp_new */
1523 CFDataRefObj_tp_free, /* tp_free */
1524};
1525
1526/* ------------------- End object type CFDataRef -------------------- */
1527
1528
1529/* ------------------ Object type CFMutableDataRef ------------------ */
1530
1531PyTypeObject CFMutableDataRef_Type;
1532
1533#define CFMutableDataRefObj_Check(x) ((x)->ob_type == &CFMutableDataRef_Type || PyObject_TypeCheck((x), &CFMutableDataRef_Type))
1534
1535typedef struct CFMutableDataRefObject {
1536 PyObject_HEAD
1537 CFMutableDataRef ob_itself;
1538 void (*ob_freeit)(CFTypeRef ptr);
1539} CFMutableDataRefObject;
1540
1541PyObject *CFMutableDataRefObj_New(CFMutableDataRef itself)
1542{
1543 CFMutableDataRefObject *it;
1544 if (itself == NULL)
1545 {
1546 PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL");
1547 return NULL;
1548 }
1549 it = PyObject_NEW(CFMutableDataRefObject, &CFMutableDataRef_Type);
1550 if (it == NULL) return NULL;
1551 /* XXXX Should we tp_init or tp_new our basetype? */
1552 it->ob_itself = itself;
1553 it->ob_freeit = CFRelease;
1554 return (PyObject *)it;
1555}
1556
1557int CFMutableDataRefObj_Convert(PyObject *v, CFMutableDataRef *p_itself)
1558{
1559
1560 if (v == Py_None) { *p_itself = NULL; return 1; }
1561 /* Check for other CF objects here */
1562
1563 if (!CFMutableDataRefObj_Check(v))
1564 {
1565 PyErr_SetString(PyExc_TypeError, "CFMutableDataRef required");
1566 return 0;
1567 }
1568 *p_itself = ((CFMutableDataRefObject *)v)->ob_itself;
1569 return 1;
1570}
1571
1572static void CFMutableDataRefObj_dealloc(CFMutableDataRefObject *self)
1573{
1574 if (self->ob_freeit && self->ob_itself)
1575 {
1576 self->ob_freeit((CFTypeRef)self->ob_itself);
1577 self->ob_itself = NULL;
1578 }
1579 CFDataRef_Type.tp_dealloc((PyObject *)self);
1580}
1581
1582static PyObject *CFMutableDataRefObj_CFDataSetLength(CFMutableDataRefObject *_self, PyObject *_args)
1583{
1584 PyObject *_res = NULL;
1585 CFIndex length;
1586#ifndef CFDataSetLength
1587 PyMac_PRECHECK(CFDataSetLength);
1588#endif
1589 if (!PyArg_ParseTuple(_args, "l",
1590 &length))
1591 return NULL;
1592 CFDataSetLength(_self->ob_itself,
1593 length);
1594 Py_INCREF(Py_None);
1595 _res = Py_None;
1596 return _res;
1597}
1598
1599static PyObject *CFMutableDataRefObj_CFDataIncreaseLength(CFMutableDataRefObject *_self, PyObject *_args)
1600{
1601 PyObject *_res = NULL;
1602 CFIndex extraLength;
1603#ifndef CFDataIncreaseLength
1604 PyMac_PRECHECK(CFDataIncreaseLength);
1605#endif
1606 if (!PyArg_ParseTuple(_args, "l",
1607 &extraLength))
1608 return NULL;
1609 CFDataIncreaseLength(_self->ob_itself,
1610 extraLength);
1611 Py_INCREF(Py_None);
1612 _res = Py_None;
1613 return _res;
1614}
1615
1616static PyObject *CFMutableDataRefObj_CFDataAppendBytes(CFMutableDataRefObject *_self, PyObject *_args)
1617{
1618 PyObject *_res = NULL;
1619 unsigned char *bytes__in__;
1620 long bytes__len__;
1621 int bytes__in_len__;
1622#ifndef CFDataAppendBytes
1623 PyMac_PRECHECK(CFDataAppendBytes);
1624#endif
1625 if (!PyArg_ParseTuple(_args, "s#",
1626 &bytes__in__, &bytes__in_len__))
1627 return NULL;
1628 bytes__len__ = bytes__in_len__;
1629 CFDataAppendBytes(_self->ob_itself,
1630 bytes__in__, bytes__len__);
1631 Py_INCREF(Py_None);
1632 _res = Py_None;
1633 return _res;
1634}
1635
1636static PyObject *CFMutableDataRefObj_CFDataReplaceBytes(CFMutableDataRefObject *_self, PyObject *_args)
1637{
1638 PyObject *_res = NULL;
1639 CFRange range;
1640 unsigned char *newBytes__in__;
1641 long newBytes__len__;
1642 int newBytes__in_len__;
1643#ifndef CFDataReplaceBytes
1644 PyMac_PRECHECK(CFDataReplaceBytes);
1645#endif
1646 if (!PyArg_ParseTuple(_args, "O&s#",
1647 CFRange_Convert, &range,
1648 &newBytes__in__, &newBytes__in_len__))
1649 return NULL;
1650 newBytes__len__ = newBytes__in_len__;
1651 CFDataReplaceBytes(_self->ob_itself,
1652 range,
1653 newBytes__in__, newBytes__len__);
1654 Py_INCREF(Py_None);
1655 _res = Py_None;
1656 return _res;
1657}
1658
1659static PyObject *CFMutableDataRefObj_CFDataDeleteBytes(CFMutableDataRefObject *_self, PyObject *_args)
1660{
1661 PyObject *_res = NULL;
1662 CFRange range;
1663#ifndef CFDataDeleteBytes
1664 PyMac_PRECHECK(CFDataDeleteBytes);
1665#endif
1666 if (!PyArg_ParseTuple(_args, "O&",
1667 CFRange_Convert, &range))
1668 return NULL;
1669 CFDataDeleteBytes(_self->ob_itself,
1670 range);
1671 Py_INCREF(Py_None);
1672 _res = Py_None;
1673 return _res;
1674}
1675
1676static PyMethodDef CFMutableDataRefObj_methods[] = {
1677 {"CFDataSetLength", (PyCFunction)CFMutableDataRefObj_CFDataSetLength, 1,
1678 PyDoc_STR("(CFIndex length) -> None")},
1679 {"CFDataIncreaseLength", (PyCFunction)CFMutableDataRefObj_CFDataIncreaseLength, 1,
1680 PyDoc_STR("(CFIndex extraLength) -> None")},
1681 {"CFDataAppendBytes", (PyCFunction)CFMutableDataRefObj_CFDataAppendBytes, 1,
1682 PyDoc_STR("(Buffer bytes) -> None")},
1683 {"CFDataReplaceBytes", (PyCFunction)CFMutableDataRefObj_CFDataReplaceBytes, 1,
1684 PyDoc_STR("(CFRange range, Buffer newBytes) -> None")},
1685 {"CFDataDeleteBytes", (PyCFunction)CFMutableDataRefObj_CFDataDeleteBytes, 1,
1686 PyDoc_STR("(CFRange range) -> None")},
1687 {NULL, NULL, 0}
1688};
1689
1690#define CFMutableDataRefObj_getsetlist NULL
1691
1692
1693static int CFMutableDataRefObj_compare(CFMutableDataRefObject *self, CFMutableDataRefObject *other)
1694{
1695 /* XXXX Or should we use CFEqual?? */
1696 if ( self->ob_itself > other->ob_itself ) return 1;
1697 if ( self->ob_itself < other->ob_itself ) return -1;
1698 return 0;
1699}
1700
1701static PyObject * CFMutableDataRefObj_repr(CFMutableDataRefObject *self)
1702{
1703 char buf[100];
1704 sprintf(buf, "<CFMutableDataRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
1705 return PyString_FromString(buf);
1706}
1707
1708static int CFMutableDataRefObj_hash(CFMutableDataRefObject *self)
1709{
1710 /* XXXX Or should we use CFHash?? */
1711 return (int)self->ob_itself;
1712}
1713static int CFMutableDataRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)
1714{
1715 CFMutableDataRef itself;
1716 char *kw[] = {"itself", 0};
1717
1718 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFMutableDataRefObj_Convert, &itself))
1719 {
1720 ((CFMutableDataRefObject *)_self)->ob_itself = itself;
1721 return 0;
1722 }
1723
1724 /* Any CFTypeRef descendent is allowed as initializer too */
1725 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself))
1726 {
1727 ((CFMutableDataRefObject *)_self)->ob_itself = itself;
1728 return 0;
1729 }
1730 return -1;
1731}
1732
1733#define CFMutableDataRefObj_tp_alloc PyType_GenericAlloc
1734
1735static PyObject *CFMutableDataRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
1736{
1737 PyObject *self;
1738 if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
1739 ((CFMutableDataRefObject *)self)->ob_itself = NULL;
1740 ((CFMutableDataRefObject *)self)->ob_freeit = CFRelease;
1741 return self;
1742}
1743
1744#define CFMutableDataRefObj_tp_free PyObject_Del
1745
1746
1747PyTypeObject CFMutableDataRef_Type = {
1748 PyObject_HEAD_INIT(NULL)
1749 0, /*ob_size*/
1750 "_CF.CFMutableDataRef", /*tp_name*/
1751 sizeof(CFMutableDataRefObject), /*tp_basicsize*/
1752 0, /*tp_itemsize*/
1753 /* methods */
1754 (destructor) CFMutableDataRefObj_dealloc, /*tp_dealloc*/
1755 0, /*tp_print*/
1756 (getattrfunc)0, /*tp_getattr*/
1757 (setattrfunc)0, /*tp_setattr*/
1758 (cmpfunc) CFMutableDataRefObj_compare, /*tp_compare*/
1759 (reprfunc) CFMutableDataRefObj_repr, /*tp_repr*/
1760 (PyNumberMethods *)0, /* tp_as_number */
1761 (PySequenceMethods *)0, /* tp_as_sequence */
1762 (PyMappingMethods *)0, /* tp_as_mapping */
1763 (hashfunc) CFMutableDataRefObj_hash, /*tp_hash*/
1764 0, /*tp_call*/
1765 0, /*tp_str*/
1766 PyObject_GenericGetAttr, /*tp_getattro*/
1767 PyObject_GenericSetAttr, /*tp_setattro */
1768 0, /*tp_as_buffer*/
1769 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
1770 0, /*tp_doc*/
1771 0, /*tp_traverse*/
1772 0, /*tp_clear*/
1773 0, /*tp_richcompare*/
1774 0, /*tp_weaklistoffset*/
1775 0, /*tp_iter*/
1776 0, /*tp_iternext*/
1777 CFMutableDataRefObj_methods, /* tp_methods */
1778 0, /*tp_members*/
1779 CFMutableDataRefObj_getsetlist, /*tp_getset*/
1780 0, /*tp_base*/
1781 0, /*tp_dict*/
1782 0, /*tp_descr_get*/
1783 0, /*tp_descr_set*/
1784 0, /*tp_dictoffset*/
1785 CFMutableDataRefObj_tp_init, /* tp_init */
1786 CFMutableDataRefObj_tp_alloc, /* tp_alloc */
1787 CFMutableDataRefObj_tp_new, /* tp_new */
1788 CFMutableDataRefObj_tp_free, /* tp_free */
1789};
1790
1791/* ---------------- End object type CFMutableDataRef ---------------- */
1792
1793
1794/* -------------------- Object type CFStringRef --------------------- */
1795
1796PyTypeObject CFStringRef_Type;
1797
1798#define CFStringRefObj_Check(x) ((x)->ob_type == &CFStringRef_Type || PyObject_TypeCheck((x), &CFStringRef_Type))
1799
1800typedef struct CFStringRefObject {
1801 PyObject_HEAD
1802 CFStringRef ob_itself;
1803 void (*ob_freeit)(CFTypeRef ptr);
1804} CFStringRefObject;
1805
1806PyObject *CFStringRefObj_New(CFStringRef itself)
1807{
1808 CFStringRefObject *it;
1809 if (itself == NULL)
1810 {
1811 PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL");
1812 return NULL;
1813 }
1814 it = PyObject_NEW(CFStringRefObject, &CFStringRef_Type);
1815 if (it == NULL) return NULL;
1816 /* XXXX Should we tp_init or tp_new our basetype? */
1817 it->ob_itself = itself;
1818 it->ob_freeit = CFRelease;
1819 return (PyObject *)it;
1820}
1821
1822int CFStringRefObj_Convert(PyObject *v, CFStringRef *p_itself)
1823{
1824
1825 if (v == Py_None) { *p_itself = NULL; return 1; }
1826 if (PyString_Check(v)) {
1827 char *cStr;
1828 if (!PyArg_Parse(v, "es", "ascii", &cStr))
1829 return 0;
1830 *p_itself = CFStringCreateWithCString((CFAllocatorRef)NULL, cStr, kCFStringEncodingASCII);
1831 PyMem_Free(cStr);
1832 return 1;
1833 }
1834 if (PyUnicode_Check(v)) {
1835 /* We use the CF types here, if Python was configured differently that will give an error */
1836 CFIndex size = PyUnicode_GetSize(v);
1837 UniChar *unichars = PyUnicode_AsUnicode(v);
1838 if (!unichars) return 0;
1839 *p_itself = CFStringCreateWithCharacters((CFAllocatorRef)NULL, unichars, size);
1840 return 1;
1841 }
1842
1843
1844 if (!CFStringRefObj_Check(v))
1845 {
1846 PyErr_SetString(PyExc_TypeError, "CFStringRef required");
1847 return 0;
1848 }
1849 *p_itself = ((CFStringRefObject *)v)->ob_itself;
1850 return 1;
1851}
1852
1853static void CFStringRefObj_dealloc(CFStringRefObject *self)
1854{
1855 if (self->ob_freeit && self->ob_itself)
1856 {
1857 self->ob_freeit((CFTypeRef)self->ob_itself);
1858 self->ob_itself = NULL;
1859 }
1860 CFTypeRef_Type.tp_dealloc((PyObject *)self);
1861}
1862
1863static PyObject *CFStringRefObj_CFStringCreateWithSubstring(CFStringRefObject *_self, PyObject *_args)
1864{
1865 PyObject *_res = NULL;
1866 CFStringRef _rv;
1867 CFRange range;
1868 if (!PyArg_ParseTuple(_args, "O&",
1869 CFRange_Convert, &range))
1870 return NULL;
1871 _rv = CFStringCreateWithSubstring((CFAllocatorRef)NULL,
1872 _self->ob_itself,
1873 range);
1874 _res = Py_BuildValue("O&",
1875 CFStringRefObj_New, _rv);
1876 return _res;
1877}
1878
1879static PyObject *CFStringRefObj_CFStringCreateCopy(CFStringRefObject *_self, PyObject *_args)
1880{
1881 PyObject *_res = NULL;
1882 CFStringRef _rv;
1883 if (!PyArg_ParseTuple(_args, ""))
1884 return NULL;
1885 _rv = CFStringCreateCopy((CFAllocatorRef)NULL,
1886 _self->ob_itself);
1887 _res = Py_BuildValue("O&",
1888 CFStringRefObj_New, _rv);
1889 return _res;
1890}
1891
1892static PyObject *CFStringRefObj_CFStringGetLength(CFStringRefObject *_self, PyObject *_args)
1893{
1894 PyObject *_res = NULL;
1895 CFIndex _rv;
1896#ifndef CFStringGetLength
1897 PyMac_PRECHECK(CFStringGetLength);
1898#endif
1899 if (!PyArg_ParseTuple(_args, ""))
1900 return NULL;
1901 _rv = CFStringGetLength(_self->ob_itself);
1902 _res = Py_BuildValue("l",
1903 _rv);
1904 return _res;
1905}
1906
1907static PyObject *CFStringRefObj_CFStringGetBytes(CFStringRefObject *_self, PyObject *_args)
1908{
1909 PyObject *_res = NULL;
1910 CFIndex _rv;
1911 CFRange range;
1912 CFStringEncoding encoding;
1913 UInt8 lossByte;
1914 Boolean isExternalRepresentation;
1915 UInt8 buffer;
1916 CFIndex maxBufLen;
1917 CFIndex usedBufLen;
1918#ifndef CFStringGetBytes
1919 PyMac_PRECHECK(CFStringGetBytes);
1920#endif
1921 if (!PyArg_ParseTuple(_args, "O&lbll",
1922 CFRange_Convert, &range,
1923 &encoding,
1924 &lossByte,
1925 &isExternalRepresentation,
1926 &maxBufLen))
1927 return NULL;
1928 _rv = CFStringGetBytes(_self->ob_itself,
1929 range,
1930 encoding,
1931 lossByte,
1932 isExternalRepresentation,
1933 &buffer,
1934 maxBufLen,
1935 &usedBufLen);
1936 _res = Py_BuildValue("lbl",
1937 _rv,
1938 buffer,
1939 usedBufLen);
1940 return _res;
1941}
1942
1943static PyObject *CFStringRefObj_CFStringCreateExternalRepresentation(CFStringRefObject *_self, PyObject *_args)
1944{
1945 PyObject *_res = NULL;
1946 CFDataRef _rv;
1947 CFStringEncoding encoding;
1948 UInt8 lossByte;
1949 if (!PyArg_ParseTuple(_args, "lb",
1950 &encoding,
1951 &lossByte))
1952 return NULL;
1953 _rv = CFStringCreateExternalRepresentation((CFAllocatorRef)NULL,
1954 _self->ob_itself,
1955 encoding,
1956 lossByte);
1957 _res = Py_BuildValue("O&",
1958 CFDataRefObj_New, _rv);
1959 return _res;
1960}
1961
1962static PyObject *CFStringRefObj_CFStringGetSmallestEncoding(CFStringRefObject *_self, PyObject *_args)
1963{
1964 PyObject *_res = NULL;
1965 CFStringEncoding _rv;
1966#ifndef CFStringGetSmallestEncoding
1967 PyMac_PRECHECK(CFStringGetSmallestEncoding);
1968#endif
1969 if (!PyArg_ParseTuple(_args, ""))
1970 return NULL;
1971 _rv = CFStringGetSmallestEncoding(_self->ob_itself);
1972 _res = Py_BuildValue("l",
1973 _rv);
1974 return _res;
1975}
1976
1977static PyObject *CFStringRefObj_CFStringGetFastestEncoding(CFStringRefObject *_self, PyObject *_args)
1978{
1979 PyObject *_res = NULL;
1980 CFStringEncoding _rv;
1981#ifndef CFStringGetFastestEncoding
1982 PyMac_PRECHECK(CFStringGetFastestEncoding);
1983#endif
1984 if (!PyArg_ParseTuple(_args, ""))
1985 return NULL;
1986 _rv = CFStringGetFastestEncoding(_self->ob_itself);
1987 _res = Py_BuildValue("l",
1988 _rv);
1989 return _res;
1990}
1991
1992static PyObject *CFStringRefObj_CFStringCompareWithOptions(CFStringRefObject *_self, PyObject *_args)
1993{
1994 PyObject *_res = NULL;
1995 CFComparisonResult _rv;
1996 CFStringRef theString2;
1997 CFRange rangeToCompare;
1998 CFOptionFlags compareOptions;
1999#ifndef CFStringCompareWithOptions
2000 PyMac_PRECHECK(CFStringCompareWithOptions);
2001#endif
2002 if (!PyArg_ParseTuple(_args, "O&O&l",
2003 CFStringRefObj_Convert, &theString2,
2004 CFRange_Convert, &rangeToCompare,
2005 &compareOptions))
2006 return NULL;
2007 _rv = CFStringCompareWithOptions(_self->ob_itself,
2008 theString2,
2009 rangeToCompare,
2010 compareOptions);
2011 _res = Py_BuildValue("l",
2012 _rv);
2013 return _res;
2014}
2015
2016static PyObject *CFStringRefObj_CFStringCompare(CFStringRefObject *_self, PyObject *_args)
2017{
2018 PyObject *_res = NULL;
2019 CFComparisonResult _rv;
2020 CFStringRef theString2;
2021 CFOptionFlags compareOptions;
2022#ifndef CFStringCompare
2023 PyMac_PRECHECK(CFStringCompare);
2024#endif
2025 if (!PyArg_ParseTuple(_args, "O&l",
2026 CFStringRefObj_Convert, &theString2,
2027 &compareOptions))
2028 return NULL;
2029 _rv = CFStringCompare(_self->ob_itself,
2030 theString2,
2031 compareOptions);
2032 _res = Py_BuildValue("l",
2033 _rv);
2034 return _res;
2035}
2036
2037static PyObject *CFStringRefObj_CFStringFindWithOptions(CFStringRefObject *_self, PyObject *_args)
2038{
2039 PyObject *_res = NULL;
2040 Boolean _rv;
2041 CFStringRef stringToFind;
2042 CFRange rangeToSearch;
2043 CFOptionFlags searchOptions;
2044 CFRange result;
2045#ifndef CFStringFindWithOptions
2046 PyMac_PRECHECK(CFStringFindWithOptions);
2047#endif
2048 if (!PyArg_ParseTuple(_args, "O&O&l",
2049 CFStringRefObj_Convert, &stringToFind,
2050 CFRange_Convert, &rangeToSearch,
2051 &searchOptions))
2052 return NULL;
2053 _rv = CFStringFindWithOptions(_self->ob_itself,
2054 stringToFind,
2055 rangeToSearch,
2056 searchOptions,
2057 &result);
2058 _res = Py_BuildValue("lO&",
2059 _rv,
2060 CFRange_New, result);
2061 return _res;
2062}
2063
2064static PyObject *CFStringRefObj_CFStringCreateArrayWithFindResults(CFStringRefObject *_self, PyObject *_args)
2065{
2066 PyObject *_res = NULL;
2067 CFArrayRef _rv;
2068 CFStringRef stringToFind;
2069 CFRange rangeToSearch;
2070 CFOptionFlags compareOptions;
2071 if (!PyArg_ParseTuple(_args, "O&O&l",
2072 CFStringRefObj_Convert, &stringToFind,
2073 CFRange_Convert, &rangeToSearch,
2074 &compareOptions))
2075 return NULL;
2076 _rv = CFStringCreateArrayWithFindResults((CFAllocatorRef)NULL,
2077 _self->ob_itself,
2078 stringToFind,
2079 rangeToSearch,
2080 compareOptions);
2081 _res = Py_BuildValue("O&",
2082 CFArrayRefObj_New, _rv);
2083 return _res;
2084}
2085
2086static PyObject *CFStringRefObj_CFStringFind(CFStringRefObject *_self, PyObject *_args)
2087{
2088 PyObject *_res = NULL;
2089 CFRange _rv;
2090 CFStringRef stringToFind;
2091 CFOptionFlags compareOptions;
2092#ifndef CFStringFind
2093 PyMac_PRECHECK(CFStringFind);
2094#endif
2095 if (!PyArg_ParseTuple(_args, "O&l",
2096 CFStringRefObj_Convert, &stringToFind,
2097 &compareOptions))
2098 return NULL;
2099 _rv = CFStringFind(_self->ob_itself,
2100 stringToFind,
2101 compareOptions);
2102 _res = Py_BuildValue("O&",
2103 CFRange_New, _rv);
2104 return _res;
2105}
2106
2107static PyObject *CFStringRefObj_CFStringHasPrefix(CFStringRefObject *_self, PyObject *_args)
2108{
2109 PyObject *_res = NULL;
2110 Boolean _rv;
2111 CFStringRef prefix;
2112#ifndef CFStringHasPrefix
2113 PyMac_PRECHECK(CFStringHasPrefix);
2114#endif
2115 if (!PyArg_ParseTuple(_args, "O&",
2116 CFStringRefObj_Convert, &prefix))
2117 return NULL;
2118 _rv = CFStringHasPrefix(_self->ob_itself,
2119 prefix);
2120 _res = Py_BuildValue("l",
2121 _rv);
2122 return _res;
2123}
2124
2125static PyObject *CFStringRefObj_CFStringHasSuffix(CFStringRefObject *_self, PyObject *_args)
2126{
2127 PyObject *_res = NULL;
2128 Boolean _rv;
2129 CFStringRef suffix;
2130#ifndef CFStringHasSuffix
2131 PyMac_PRECHECK(CFStringHasSuffix);
2132#endif
2133 if (!PyArg_ParseTuple(_args, "O&",
2134 CFStringRefObj_Convert, &suffix))
2135 return NULL;
2136 _rv = CFStringHasSuffix(_self->ob_itself,
2137 suffix);
2138 _res = Py_BuildValue("l",
2139 _rv);
2140 return _res;
2141}
2142
2143static PyObject *CFStringRefObj_CFStringGetLineBounds(CFStringRefObject *_self, PyObject *_args)
2144{
2145 PyObject *_res = NULL;
2146 CFRange range;
2147 CFIndex lineBeginIndex;
2148 CFIndex lineEndIndex;
2149 CFIndex contentsEndIndex;
2150#ifndef CFStringGetLineBounds
2151 PyMac_PRECHECK(CFStringGetLineBounds);
2152#endif
2153 if (!PyArg_ParseTuple(_args, "O&",
2154 CFRange_Convert, &range))
2155 return NULL;
2156 CFStringGetLineBounds(_self->ob_itself,
2157 range,
2158 &lineBeginIndex,
2159 &lineEndIndex,
2160 &contentsEndIndex);
2161 _res = Py_BuildValue("lll",
2162 lineBeginIndex,
2163 lineEndIndex,
2164 contentsEndIndex);
2165 return _res;
2166}
2167
2168static PyObject *CFStringRefObj_CFStringCreateArrayBySeparatingStrings(CFStringRefObject *_self, PyObject *_args)
2169{
2170 PyObject *_res = NULL;
2171 CFArrayRef _rv;
2172 CFStringRef separatorString;
2173 if (!PyArg_ParseTuple(_args, "O&",
2174 CFStringRefObj_Convert, &separatorString))
2175 return NULL;
2176 _rv = CFStringCreateArrayBySeparatingStrings((CFAllocatorRef)NULL,
2177 _self->ob_itself,
2178 separatorString);
2179 _res = Py_BuildValue("O&",
2180 CFArrayRefObj_New, _rv);
2181 return _res;
2182}
2183
2184static PyObject *CFStringRefObj_CFStringGetIntValue(CFStringRefObject *_self, PyObject *_args)
2185{
2186 PyObject *_res = NULL;
2187 SInt32 _rv;
2188#ifndef CFStringGetIntValue
2189 PyMac_PRECHECK(CFStringGetIntValue);
2190#endif
2191 if (!PyArg_ParseTuple(_args, ""))
2192 return NULL;
2193 _rv = CFStringGetIntValue(_self->ob_itself);
2194 _res = Py_BuildValue("l",
2195 _rv);
2196 return _res;
2197}
2198
2199static PyObject *CFStringRefObj_CFStringGetDoubleValue(CFStringRefObject *_self, PyObject *_args)
2200{
2201 PyObject *_res = NULL;
2202 double _rv;
2203#ifndef CFStringGetDoubleValue
2204 PyMac_PRECHECK(CFStringGetDoubleValue);
2205#endif
2206 if (!PyArg_ParseTuple(_args, ""))
2207 return NULL;
2208 _rv = CFStringGetDoubleValue(_self->ob_itself);
2209 _res = Py_BuildValue("d",
2210 _rv);
2211 return _res;
2212}
2213
2214static PyObject *CFStringRefObj_CFStringConvertIANACharSetNameToEncoding(CFStringRefObject *_self, PyObject *_args)
2215{
2216 PyObject *_res = NULL;
2217 CFStringEncoding _rv;
2218#ifndef CFStringConvertIANACharSetNameToEncoding
2219 PyMac_PRECHECK(CFStringConvertIANACharSetNameToEncoding);
2220#endif
2221 if (!PyArg_ParseTuple(_args, ""))
2222 return NULL;
2223 _rv = CFStringConvertIANACharSetNameToEncoding(_self->ob_itself);
2224 _res = Py_BuildValue("l",
2225 _rv);
2226 return _res;
2227}
2228
2229static PyObject *CFStringRefObj_CFShowStr(CFStringRefObject *_self, PyObject *_args)
2230{
2231 PyObject *_res = NULL;
2232#ifndef CFShowStr
2233 PyMac_PRECHECK(CFShowStr);
2234#endif
2235 if (!PyArg_ParseTuple(_args, ""))
2236 return NULL;
2237 CFShowStr(_self->ob_itself);
2238 Py_INCREF(Py_None);
2239 _res = Py_None;
2240 return _res;
2241}
2242
2243static PyObject *CFStringRefObj_CFURLCreateWithString(CFStringRefObject *_self, PyObject *_args)
2244{
2245 PyObject *_res = NULL;
2246 CFURLRef _rv;
2247 CFURLRef baseURL;
2248 if (!PyArg_ParseTuple(_args, "O&",
2249 OptionalCFURLRefObj_Convert, &baseURL))
2250 return NULL;
2251 _rv = CFURLCreateWithString((CFAllocatorRef)NULL,
2252 _self->ob_itself,
2253 baseURL);
2254 _res = Py_BuildValue("O&",
2255 CFURLRefObj_New, _rv);
2256 return _res;
2257}
2258
2259static PyObject *CFStringRefObj_CFURLCreateWithFileSystemPath(CFStringRefObject *_self, PyObject *_args)
2260{
2261 PyObject *_res = NULL;
2262 CFURLRef _rv;
2263 CFURLPathStyle pathStyle;
2264 Boolean isDirectory;
2265 if (!PyArg_ParseTuple(_args, "ll",
2266 &pathStyle,
2267 &isDirectory))
2268 return NULL;
2269 _rv = CFURLCreateWithFileSystemPath((CFAllocatorRef)NULL,
2270 _self->ob_itself,
2271 pathStyle,
2272 isDirectory);
2273 _res = Py_BuildValue("O&",
2274 CFURLRefObj_New, _rv);
2275 return _res;
2276}
2277
2278static PyObject *CFStringRefObj_CFURLCreateWithFileSystemPathRelativeToBase(CFStringRefObject *_self, PyObject *_args)
2279{
2280 PyObject *_res = NULL;
2281 CFURLRef _rv;
2282 CFURLPathStyle pathStyle;
2283 Boolean isDirectory;
2284 CFURLRef baseURL;
2285 if (!PyArg_ParseTuple(_args, "llO&",
2286 &pathStyle,
2287 &isDirectory,
2288 OptionalCFURLRefObj_Convert, &baseURL))
2289 return NULL;
2290 _rv = CFURLCreateWithFileSystemPathRelativeToBase((CFAllocatorRef)NULL,
2291 _self->ob_itself,
2292 pathStyle,
2293 isDirectory,
2294 baseURL);
2295 _res = Py_BuildValue("O&",
2296 CFURLRefObj_New, _rv);
2297 return _res;
2298}
2299
2300static PyObject *CFStringRefObj_CFURLCreateStringByReplacingPercentEscapes(CFStringRefObject *_self, PyObject *_args)
2301{
2302 PyObject *_res = NULL;
2303 CFStringRef _rv;
2304 CFStringRef charactersToLeaveEscaped;
2305 if (!PyArg_ParseTuple(_args, "O&",
2306 CFStringRefObj_Convert, &charactersToLeaveEscaped))
2307 return NULL;
2308 _rv = CFURLCreateStringByReplacingPercentEscapes((CFAllocatorRef)NULL,
2309 _self->ob_itself,
2310 charactersToLeaveEscaped);
2311 _res = Py_BuildValue("O&",
2312 CFStringRefObj_New, _rv);
2313 return _res;
2314}
2315
2316static PyObject *CFStringRefObj_CFURLCreateStringByAddingPercentEscapes(CFStringRefObject *_self, PyObject *_args)
2317{
2318 PyObject *_res = NULL;
2319 CFStringRef _rv;
2320 CFStringRef charactersToLeaveUnescaped;
2321 CFStringRef legalURLCharactersToBeEscaped;
2322 CFStringEncoding encoding;
2323 if (!PyArg_ParseTuple(_args, "O&O&l",
2324 CFStringRefObj_Convert, &charactersToLeaveUnescaped,
2325 CFStringRefObj_Convert, &legalURLCharactersToBeEscaped,
2326 &encoding))
2327 return NULL;
2328 _rv = CFURLCreateStringByAddingPercentEscapes((CFAllocatorRef)NULL,
2329 _self->ob_itself,
2330 charactersToLeaveUnescaped,
2331 legalURLCharactersToBeEscaped,
2332 encoding);
2333 _res = Py_BuildValue("O&",
2334 CFStringRefObj_New, _rv);
2335 return _res;
2336}
2337
2338static PyObject *CFStringRefObj_CFStringGetString(CFStringRefObject *_self, PyObject *_args)
2339{
2340 PyObject *_res = NULL;
2341
2342 int size = CFStringGetLength(_self->ob_itself)+1;
2343 char *data = malloc(size);
2344
2345 if( data == NULL ) return PyErr_NoMemory();
2346 if ( CFStringGetCString(_self->ob_itself, data, size, 0) ) {
2347 _res = (PyObject *)PyString_FromString(data);
2348 } else {
2349 PyErr_SetString(PyExc_RuntimeError, "CFStringGetCString could not fit the string");
2350 _res = NULL;
2351 }
2352 free(data);
2353 return _res;
2354
2355}
2356
2357static PyObject *CFStringRefObj_CFStringGetUnicode(CFStringRefObject *_self, PyObject *_args)
2358{
2359 PyObject *_res = NULL;
2360
2361 int size = CFStringGetLength(_self->ob_itself)+1;
2362 Py_UNICODE *data = malloc(size*sizeof(Py_UNICODE));
2363 CFRange range;
2364
2365 range.location = 0;
2366 range.length = size;
2367 if( data == NULL ) return PyErr_NoMemory();
2368 CFStringGetCharacters(_self->ob_itself, range, data);
2369 _res = (PyObject *)PyUnicode_FromUnicode(data, size-1);
2370 free(data);
2371 return _res;
2372
2373}
2374
2375static PyMethodDef CFStringRefObj_methods[] = {
2376 {"CFStringCreateWithSubstring", (PyCFunction)CFStringRefObj_CFStringCreateWithSubstring, 1,
2377 PyDoc_STR("(CFRange range) -> (CFStringRef _rv)")},
2378 {"CFStringCreateCopy", (PyCFunction)CFStringRefObj_CFStringCreateCopy, 1,
2379 PyDoc_STR("() -> (CFStringRef _rv)")},
2380 {"CFStringGetLength", (PyCFunction)CFStringRefObj_CFStringGetLength, 1,
2381 PyDoc_STR("() -> (CFIndex _rv)")},
2382 {"CFStringGetBytes", (PyCFunction)CFStringRefObj_CFStringGetBytes, 1,
2383 PyDoc_STR("(CFRange range, CFStringEncoding encoding, UInt8 lossByte, Boolean isExternalRepresentation, CFIndex maxBufLen) -> (CFIndex _rv, UInt8 buffer, CFIndex usedBufLen)")},
2384 {"CFStringCreateExternalRepresentation", (PyCFunction)CFStringRefObj_CFStringCreateExternalRepresentation, 1,
2385 PyDoc_STR("(CFStringEncoding encoding, UInt8 lossByte) -> (CFDataRef _rv)")},
2386 {"CFStringGetSmallestEncoding", (PyCFunction)CFStringRefObj_CFStringGetSmallestEncoding, 1,
2387 PyDoc_STR("() -> (CFStringEncoding _rv)")},
2388 {"CFStringGetFastestEncoding", (PyCFunction)CFStringRefObj_CFStringGetFastestEncoding, 1,
2389 PyDoc_STR("() -> (CFStringEncoding _rv)")},
2390 {"CFStringCompareWithOptions", (PyCFunction)CFStringRefObj_CFStringCompareWithOptions, 1,
2391 PyDoc_STR("(CFStringRef theString2, CFRange rangeToCompare, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)")},
2392 {"CFStringCompare", (PyCFunction)CFStringRefObj_CFStringCompare, 1,
2393 PyDoc_STR("(CFStringRef theString2, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)")},
2394 {"CFStringFindWithOptions", (PyCFunction)CFStringRefObj_CFStringFindWithOptions, 1,
2395 PyDoc_STR("(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags searchOptions) -> (Boolean _rv, CFRange result)")},
2396 {"CFStringCreateArrayWithFindResults", (PyCFunction)CFStringRefObj_CFStringCreateArrayWithFindResults, 1,
2397 PyDoc_STR("(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags compareOptions) -> (CFArrayRef _rv)")},
2398 {"CFStringFind", (PyCFunction)CFStringRefObj_CFStringFind, 1,
2399 PyDoc_STR("(CFStringRef stringToFind, CFOptionFlags compareOptions) -> (CFRange _rv)")},
2400 {"CFStringHasPrefix", (PyCFunction)CFStringRefObj_CFStringHasPrefix, 1,
2401 PyDoc_STR("(CFStringRef prefix) -> (Boolean _rv)")},
2402 {"CFStringHasSuffix", (PyCFunction)CFStringRefObj_CFStringHasSuffix, 1,
2403 PyDoc_STR("(CFStringRef suffix) -> (Boolean _rv)")},
2404 {"CFStringGetLineBounds", (PyCFunction)CFStringRefObj_CFStringGetLineBounds, 1,
2405 PyDoc_STR("(CFRange range) -> (CFIndex lineBeginIndex, CFIndex lineEndIndex, CFIndex contentsEndIndex)")},
2406 {"CFStringCreateArrayBySeparatingStrings", (PyCFunction)CFStringRefObj_CFStringCreateArrayBySeparatingStrings, 1,
2407 PyDoc_STR("(CFStringRef separatorString) -> (CFArrayRef _rv)")},
2408 {"CFStringGetIntValue", (PyCFunction)CFStringRefObj_CFStringGetIntValue, 1,
2409 PyDoc_STR("() -> (SInt32 _rv)")},
2410 {"CFStringGetDoubleValue", (PyCFunction)CFStringRefObj_CFStringGetDoubleValue, 1,
2411 PyDoc_STR("() -> (double _rv)")},
2412 {"CFStringConvertIANACharSetNameToEncoding", (PyCFunction)CFStringRefObj_CFStringConvertIANACharSetNameToEncoding, 1,
2413 PyDoc_STR("() -> (CFStringEncoding _rv)")},
2414 {"CFShowStr", (PyCFunction)CFStringRefObj_CFShowStr, 1,
2415 PyDoc_STR("() -> None")},
2416 {"CFURLCreateWithString", (PyCFunction)CFStringRefObj_CFURLCreateWithString, 1,
2417 PyDoc_STR("(CFURLRef baseURL) -> (CFURLRef _rv)")},
2418 {"CFURLCreateWithFileSystemPath", (PyCFunction)CFStringRefObj_CFURLCreateWithFileSystemPath, 1,
2419 PyDoc_STR("(CFURLPathStyle pathStyle, Boolean isDirectory) -> (CFURLRef _rv)")},
2420 {"CFURLCreateWithFileSystemPathRelativeToBase", (PyCFunction)CFStringRefObj_CFURLCreateWithFileSystemPathRelativeToBase, 1,
2421 PyDoc_STR("(CFURLPathStyle pathStyle, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)")},
2422 {"CFURLCreateStringByReplacingPercentEscapes", (PyCFunction)CFStringRefObj_CFURLCreateStringByReplacingPercentEscapes, 1,
2423 PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")},
2424 {"CFURLCreateStringByAddingPercentEscapes", (PyCFunction)CFStringRefObj_CFURLCreateStringByAddingPercentEscapes, 1,
2425 PyDoc_STR("(CFStringRef charactersToLeaveUnescaped, CFStringRef legalURLCharactersToBeEscaped, CFStringEncoding encoding) -> (CFStringRef _rv)")},
2426 {"CFStringGetString", (PyCFunction)CFStringRefObj_CFStringGetString, 1,
2427 PyDoc_STR("() -> (string _rv)")},
2428 {"CFStringGetUnicode", (PyCFunction)CFStringRefObj_CFStringGetUnicode, 1,
2429 PyDoc_STR("() -> (unicode _rv)")},
2430 {NULL, NULL, 0}
2431};
2432
2433#define CFStringRefObj_getsetlist NULL
2434
2435
2436static int CFStringRefObj_compare(CFStringRefObject *self, CFStringRefObject *other)
2437{
2438 /* XXXX Or should we use CFEqual?? */
2439 if ( self->ob_itself > other->ob_itself ) return 1;
2440 if ( self->ob_itself < other->ob_itself ) return -1;
2441 return 0;
2442}
2443
2444static PyObject * CFStringRefObj_repr(CFStringRefObject *self)
2445{
2446 char buf[100];
2447 sprintf(buf, "<CFStringRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
2448 return PyString_FromString(buf);
2449}
2450
2451static int CFStringRefObj_hash(CFStringRefObject *self)
2452{
2453 /* XXXX Or should we use CFHash?? */
2454 return (int)self->ob_itself;
2455}
2456static int CFStringRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)
2457{
2458 CFStringRef itself;
2459 char *kw[] = {"itself", 0};
2460
2461 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFStringRefObj_Convert, &itself))
2462 {
2463 ((CFStringRefObject *)_self)->ob_itself = itself;
2464 return 0;
2465 }
2466
2467 /* Any CFTypeRef descendent is allowed as initializer too */
2468 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself))
2469 {
2470 ((CFStringRefObject *)_self)->ob_itself = itself;
2471 return 0;
2472 }
2473 return -1;
2474}
2475
2476#define CFStringRefObj_tp_alloc PyType_GenericAlloc
2477
2478static PyObject *CFStringRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
2479{
2480 PyObject *self;
2481 if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
2482 ((CFStringRefObject *)self)->ob_itself = NULL;
2483 ((CFStringRefObject *)self)->ob_freeit = CFRelease;
2484 return self;
2485}
2486
2487#define CFStringRefObj_tp_free PyObject_Del
2488
2489
2490PyTypeObject CFStringRef_Type = {
2491 PyObject_HEAD_INIT(NULL)
2492 0, /*ob_size*/
2493 "_CF.CFStringRef", /*tp_name*/
2494 sizeof(CFStringRefObject), /*tp_basicsize*/
2495 0, /*tp_itemsize*/
2496 /* methods */
2497 (destructor) CFStringRefObj_dealloc, /*tp_dealloc*/
2498 0, /*tp_print*/
2499 (getattrfunc)0, /*tp_getattr*/
2500 (setattrfunc)0, /*tp_setattr*/
2501 (cmpfunc) CFStringRefObj_compare, /*tp_compare*/
2502 (reprfunc) CFStringRefObj_repr, /*tp_repr*/
2503 (PyNumberMethods *)0, /* tp_as_number */
2504 (PySequenceMethods *)0, /* tp_as_sequence */
2505 (PyMappingMethods *)0, /* tp_as_mapping */
2506 (hashfunc) CFStringRefObj_hash, /*tp_hash*/
2507 0, /*tp_call*/
2508 0, /*tp_str*/
2509 PyObject_GenericGetAttr, /*tp_getattro*/
2510 PyObject_GenericSetAttr, /*tp_setattro */
2511 0, /*tp_as_buffer*/
2512 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
2513 0, /*tp_doc*/
2514 0, /*tp_traverse*/
2515 0, /*tp_clear*/
2516 0, /*tp_richcompare*/
2517 0, /*tp_weaklistoffset*/
2518 0, /*tp_iter*/
2519 0, /*tp_iternext*/
2520 CFStringRefObj_methods, /* tp_methods */
2521 0, /*tp_members*/
2522 CFStringRefObj_getsetlist, /*tp_getset*/
2523 0, /*tp_base*/
2524 0, /*tp_dict*/
2525 0, /*tp_descr_get*/
2526 0, /*tp_descr_set*/
2527 0, /*tp_dictoffset*/
2528 CFStringRefObj_tp_init, /* tp_init */
2529 CFStringRefObj_tp_alloc, /* tp_alloc */
2530 CFStringRefObj_tp_new, /* tp_new */
2531 CFStringRefObj_tp_free, /* tp_free */
2532};
2533
2534/* ------------------ End object type CFStringRef ------------------- */
2535
2536
2537/* ----------------- Object type CFMutableStringRef ----------------- */
2538
2539PyTypeObject CFMutableStringRef_Type;
2540
2541#define CFMutableStringRefObj_Check(x) ((x)->ob_type == &CFMutableStringRef_Type || PyObject_TypeCheck((x), &CFMutableStringRef_Type))
2542
2543typedef struct CFMutableStringRefObject {
2544 PyObject_HEAD
2545 CFMutableStringRef ob_itself;
2546 void (*ob_freeit)(CFTypeRef ptr);
2547} CFMutableStringRefObject;
2548
2549PyObject *CFMutableStringRefObj_New(CFMutableStringRef itself)
2550{
2551 CFMutableStringRefObject *it;
2552 if (itself == NULL)
2553 {
2554 PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL");
2555 return NULL;
2556 }
2557 it = PyObject_NEW(CFMutableStringRefObject, &CFMutableStringRef_Type);
2558 if (it == NULL) return NULL;
2559 /* XXXX Should we tp_init or tp_new our basetype? */
2560 it->ob_itself = itself;
2561 it->ob_freeit = CFRelease;
2562 return (PyObject *)it;
2563}
2564
2565int CFMutableStringRefObj_Convert(PyObject *v, CFMutableStringRef *p_itself)
2566{
2567
2568 if (v == Py_None) { *p_itself = NULL; return 1; }
2569 /* Check for other CF objects here */
2570
2571 if (!CFMutableStringRefObj_Check(v))
2572 {
2573 PyErr_SetString(PyExc_TypeError, "CFMutableStringRef required");
2574 return 0;
2575 }
2576 *p_itself = ((CFMutableStringRefObject *)v)->ob_itself;
2577 return 1;
2578}
2579
2580static void CFMutableStringRefObj_dealloc(CFMutableStringRefObject *self)
2581{
2582 if (self->ob_freeit && self->ob_itself)
2583 {
2584 self->ob_freeit((CFTypeRef)self->ob_itself);
2585 self->ob_itself = NULL;
2586 }
2587 CFStringRef_Type.tp_dealloc((PyObject *)self);
2588}
2589
2590static PyObject *CFMutableStringRefObj_CFStringAppend(CFMutableStringRefObject *_self, PyObject *_args)
2591{
2592 PyObject *_res = NULL;
2593 CFStringRef appendedString;
2594#ifndef CFStringAppend
2595 PyMac_PRECHECK(CFStringAppend);
2596#endif
2597 if (!PyArg_ParseTuple(_args, "O&",
2598 CFStringRefObj_Convert, &appendedString))
2599 return NULL;
2600 CFStringAppend(_self->ob_itself,
2601 appendedString);
2602 Py_INCREF(Py_None);
2603 _res = Py_None;
2604 return _res;
2605}
2606
2607static PyObject *CFMutableStringRefObj_CFStringAppendCharacters(CFMutableStringRefObject *_self, PyObject *_args)
2608{
2609 PyObject *_res = NULL;
2610 UniChar *chars__in__;
2611 UniCharCount chars__len__;
2612 int chars__in_len__;
2613#ifndef CFStringAppendCharacters
2614 PyMac_PRECHECK(CFStringAppendCharacters);
2615#endif
2616 if (!PyArg_ParseTuple(_args, "u#",
2617 &chars__in__, &chars__in_len__))
2618 return NULL;
2619 chars__len__ = chars__in_len__;
2620 CFStringAppendCharacters(_self->ob_itself,
2621 chars__in__, chars__len__);
2622 Py_INCREF(Py_None);
2623 _res = Py_None;
2624 return _res;
2625}
2626
2627static PyObject *CFMutableStringRefObj_CFStringAppendPascalString(CFMutableStringRefObject *_self, PyObject *_args)
2628{
2629 PyObject *_res = NULL;
2630 Str255 pStr;
2631 CFStringEncoding encoding;
2632#ifndef CFStringAppendPascalString
2633 PyMac_PRECHECK(CFStringAppendPascalString);
2634#endif
2635 if (!PyArg_ParseTuple(_args, "O&l",
2636 PyMac_GetStr255, pStr,
2637 &encoding))
2638 return NULL;
2639 CFStringAppendPascalString(_self->ob_itself,
2640 pStr,
2641 encoding);
2642 Py_INCREF(Py_None);
2643 _res = Py_None;
2644 return _res;
2645}
2646
2647static PyObject *CFMutableStringRefObj_CFStringAppendCString(CFMutableStringRefObject *_self, PyObject *_args)
2648{
2649 PyObject *_res = NULL;
2650 char* cStr;
2651 CFStringEncoding encoding;
2652#ifndef CFStringAppendCString
2653 PyMac_PRECHECK(CFStringAppendCString);
2654#endif
2655 if (!PyArg_ParseTuple(_args, "sl",
2656 &cStr,
2657 &encoding))
2658 return NULL;
2659 CFStringAppendCString(_self->ob_itself,
2660 cStr,
2661 encoding);
2662 Py_INCREF(Py_None);
2663 _res = Py_None;
2664 return _res;
2665}
2666
2667static PyObject *CFMutableStringRefObj_CFStringInsert(CFMutableStringRefObject *_self, PyObject *_args)
2668{
2669 PyObject *_res = NULL;
2670 CFIndex idx;
2671 CFStringRef insertedStr;
2672#ifndef CFStringInsert
2673 PyMac_PRECHECK(CFStringInsert);
2674#endif
2675 if (!PyArg_ParseTuple(_args, "lO&",
2676 &idx,
2677 CFStringRefObj_Convert, &insertedStr))
2678 return NULL;
2679 CFStringInsert(_self->ob_itself,
2680 idx,
2681 insertedStr);
2682 Py_INCREF(Py_None);
2683 _res = Py_None;
2684 return _res;
2685}
2686
2687static PyObject *CFMutableStringRefObj_CFStringDelete(CFMutableStringRefObject *_self, PyObject *_args)
2688{
2689 PyObject *_res = NULL;
2690 CFRange range;
2691#ifndef CFStringDelete
2692 PyMac_PRECHECK(CFStringDelete);
2693#endif
2694 if (!PyArg_ParseTuple(_args, "O&",
2695 CFRange_Convert, &range))
2696 return NULL;
2697 CFStringDelete(_self->ob_itself,
2698 range);
2699 Py_INCREF(Py_None);
2700 _res = Py_None;
2701 return _res;
2702}
2703
2704static PyObject *CFMutableStringRefObj_CFStringReplace(CFMutableStringRefObject *_self, PyObject *_args)
2705{
2706 PyObject *_res = NULL;
2707 CFRange range;
2708 CFStringRef replacement;
2709#ifndef CFStringReplace
2710 PyMac_PRECHECK(CFStringReplace);
2711#endif
2712 if (!PyArg_ParseTuple(_args, "O&O&",
2713 CFRange_Convert, &range,
2714 CFStringRefObj_Convert, &replacement))
2715 return NULL;
2716 CFStringReplace(_self->ob_itself,
2717 range,
2718 replacement);
2719 Py_INCREF(Py_None);
2720 _res = Py_None;
2721 return _res;
2722}
2723
2724static PyObject *CFMutableStringRefObj_CFStringReplaceAll(CFMutableStringRefObject *_self, PyObject *_args)
2725{
2726 PyObject *_res = NULL;
2727 CFStringRef replacement;
2728#ifndef CFStringReplaceAll
2729 PyMac_PRECHECK(CFStringReplaceAll);
2730#endif
2731 if (!PyArg_ParseTuple(_args, "O&",
2732 CFStringRefObj_Convert, &replacement))
2733 return NULL;
2734 CFStringReplaceAll(_self->ob_itself,
2735 replacement);
2736 Py_INCREF(Py_None);
2737 _res = Py_None;
2738 return _res;
2739}
2740
2741static PyObject *CFMutableStringRefObj_CFStringPad(CFMutableStringRefObject *_self, PyObject *_args)
2742{
2743 PyObject *_res = NULL;
2744 CFStringRef padString;
2745 CFIndex length;
2746 CFIndex indexIntoPad;
2747#ifndef CFStringPad
2748 PyMac_PRECHECK(CFStringPad);
2749#endif
2750 if (!PyArg_ParseTuple(_args, "O&ll",
2751 CFStringRefObj_Convert, &padString,
2752 &length,
2753 &indexIntoPad))
2754 return NULL;
2755 CFStringPad(_self->ob_itself,
2756 padString,
2757 length,
2758 indexIntoPad);
2759 Py_INCREF(Py_None);
2760 _res = Py_None;
2761 return _res;
2762}
2763
2764static PyObject *CFMutableStringRefObj_CFStringTrim(CFMutableStringRefObject *_self, PyObject *_args)
2765{
2766 PyObject *_res = NULL;
2767 CFStringRef trimString;
2768#ifndef CFStringTrim
2769 PyMac_PRECHECK(CFStringTrim);
2770#endif
2771 if (!PyArg_ParseTuple(_args, "O&",
2772 CFStringRefObj_Convert, &trimString))
2773 return NULL;
2774 CFStringTrim(_self->ob_itself,
2775 trimString);
2776 Py_INCREF(Py_None);
2777 _res = Py_None;
2778 return _res;
2779}
2780
2781static PyObject *CFMutableStringRefObj_CFStringTrimWhitespace(CFMutableStringRefObject *_self, PyObject *_args)
2782{
2783 PyObject *_res = NULL;
2784#ifndef CFStringTrimWhitespace
2785 PyMac_PRECHECK(CFStringTrimWhitespace);
2786#endif
2787 if (!PyArg_ParseTuple(_args, ""))
2788 return NULL;
2789 CFStringTrimWhitespace(_self->ob_itself);
2790 Py_INCREF(Py_None);
2791 _res = Py_None;
2792 return _res;
2793}
2794
2795static PyMethodDef CFMutableStringRefObj_methods[] = {
2796 {"CFStringAppend", (PyCFunction)CFMutableStringRefObj_CFStringAppend, 1,
2797 PyDoc_STR("(CFStringRef appendedString) -> None")},
2798 {"CFStringAppendCharacters", (PyCFunction)CFMutableStringRefObj_CFStringAppendCharacters, 1,
2799 PyDoc_STR("(Buffer chars) -> None")},
2800 {"CFStringAppendPascalString", (PyCFunction)CFMutableStringRefObj_CFStringAppendPascalString, 1,
2801 PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> None")},
2802 {"CFStringAppendCString", (PyCFunction)CFMutableStringRefObj_CFStringAppendCString, 1,
2803 PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> None")},
2804 {"CFStringInsert", (PyCFunction)CFMutableStringRefObj_CFStringInsert, 1,
2805 PyDoc_STR("(CFIndex idx, CFStringRef insertedStr) -> None")},
2806 {"CFStringDelete", (PyCFunction)CFMutableStringRefObj_CFStringDelete, 1,
2807 PyDoc_STR("(CFRange range) -> None")},
2808 {"CFStringReplace", (PyCFunction)CFMutableStringRefObj_CFStringReplace, 1,
2809 PyDoc_STR("(CFRange range, CFStringRef replacement) -> None")},
2810 {"CFStringReplaceAll", (PyCFunction)CFMutableStringRefObj_CFStringReplaceAll, 1,
2811 PyDoc_STR("(CFStringRef replacement) -> None")},
2812 {"CFStringPad", (PyCFunction)CFMutableStringRefObj_CFStringPad, 1,
2813 PyDoc_STR("(CFStringRef padString, CFIndex length, CFIndex indexIntoPad) -> None")},
2814 {"CFStringTrim", (PyCFunction)CFMutableStringRefObj_CFStringTrim, 1,
2815 PyDoc_STR("(CFStringRef trimString) -> None")},
2816 {"CFStringTrimWhitespace", (PyCFunction)CFMutableStringRefObj_CFStringTrimWhitespace, 1,
2817 PyDoc_STR("() -> None")},
2818 {NULL, NULL, 0}
2819};
2820
2821#define CFMutableStringRefObj_getsetlist NULL
2822
2823
2824static int CFMutableStringRefObj_compare(CFMutableStringRefObject *self, CFMutableStringRefObject *other)
2825{
2826 /* XXXX Or should we use CFEqual?? */
2827 if ( self->ob_itself > other->ob_itself ) return 1;
2828 if ( self->ob_itself < other->ob_itself ) return -1;
2829 return 0;
2830}
2831
2832static PyObject * CFMutableStringRefObj_repr(CFMutableStringRefObject *self)
2833{
2834 char buf[100];
2835 sprintf(buf, "<CFMutableStringRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
2836 return PyString_FromString(buf);
2837}
2838
2839static int CFMutableStringRefObj_hash(CFMutableStringRefObject *self)
2840{
2841 /* XXXX Or should we use CFHash?? */
2842 return (int)self->ob_itself;
2843}
2844static int CFMutableStringRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)
2845{
2846 CFMutableStringRef itself;
2847 char *kw[] = {"itself", 0};
2848
2849 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFMutableStringRefObj_Convert, &itself))
2850 {
2851 ((CFMutableStringRefObject *)_self)->ob_itself = itself;
2852 return 0;
2853 }
2854
2855 /* Any CFTypeRef descendent is allowed as initializer too */
2856 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself))
2857 {
2858 ((CFMutableStringRefObject *)_self)->ob_itself = itself;
2859 return 0;
2860 }
2861 return -1;
2862}
2863
2864#define CFMutableStringRefObj_tp_alloc PyType_GenericAlloc
2865
2866static PyObject *CFMutableStringRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
2867{
2868 PyObject *self;
2869 if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
2870 ((CFMutableStringRefObject *)self)->ob_itself = NULL;
2871 ((CFMutableStringRefObject *)self)->ob_freeit = CFRelease;
2872 return self;
2873}
2874
2875#define CFMutableStringRefObj_tp_free PyObject_Del
2876
2877
2878PyTypeObject CFMutableStringRef_Type = {
2879 PyObject_HEAD_INIT(NULL)
2880 0, /*ob_size*/
2881 "_CF.CFMutableStringRef", /*tp_name*/
2882 sizeof(CFMutableStringRefObject), /*tp_basicsize*/
2883 0, /*tp_itemsize*/
2884 /* methods */
2885 (destructor) CFMutableStringRefObj_dealloc, /*tp_dealloc*/
2886 0, /*tp_print*/
2887 (getattrfunc)0, /*tp_getattr*/
2888 (setattrfunc)0, /*tp_setattr*/
2889 (cmpfunc) CFMutableStringRefObj_compare, /*tp_compare*/
2890 (reprfunc) CFMutableStringRefObj_repr, /*tp_repr*/
2891 (PyNumberMethods *)0, /* tp_as_number */
2892 (PySequenceMethods *)0, /* tp_as_sequence */
2893 (PyMappingMethods *)0, /* tp_as_mapping */
2894 (hashfunc) CFMutableStringRefObj_hash, /*tp_hash*/
2895 0, /*tp_call*/
2896 0, /*tp_str*/
2897 PyObject_GenericGetAttr, /*tp_getattro*/
2898 PyObject_GenericSetAttr, /*tp_setattro */
2899 0, /*tp_as_buffer*/
2900 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
2901 0, /*tp_doc*/
2902 0, /*tp_traverse*/
2903 0, /*tp_clear*/
2904 0, /*tp_richcompare*/
2905 0, /*tp_weaklistoffset*/
2906 0, /*tp_iter*/
2907 0, /*tp_iternext*/
2908 CFMutableStringRefObj_methods, /* tp_methods */
2909 0, /*tp_members*/
2910 CFMutableStringRefObj_getsetlist, /*tp_getset*/
2911 0, /*tp_base*/
2912 0, /*tp_dict*/
2913 0, /*tp_descr_get*/
2914 0, /*tp_descr_set*/
2915 0, /*tp_dictoffset*/
2916 CFMutableStringRefObj_tp_init, /* tp_init */
2917 CFMutableStringRefObj_tp_alloc, /* tp_alloc */
2918 CFMutableStringRefObj_tp_new, /* tp_new */
2919 CFMutableStringRefObj_tp_free, /* tp_free */
2920};
2921
2922/* --------------- End object type CFMutableStringRef --------------- */
2923
2924
2925/* ---------------------- Object type CFURLRef ---------------------- */
2926
2927PyTypeObject CFURLRef_Type;
2928
2929#define CFURLRefObj_Check(x) ((x)->ob_type == &CFURLRef_Type || PyObject_TypeCheck((x), &CFURLRef_Type))
2930
2931typedef struct CFURLRefObject {
2932 PyObject_HEAD
2933 CFURLRef ob_itself;
2934 void (*ob_freeit)(CFTypeRef ptr);
2935} CFURLRefObject;
2936
2937PyObject *CFURLRefObj_New(CFURLRef itself)
2938{
2939 CFURLRefObject *it;
2940 if (itself == NULL)
2941 {
2942 PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL");
2943 return NULL;
2944 }
2945 it = PyObject_NEW(CFURLRefObject, &CFURLRef_Type);
2946 if (it == NULL) return NULL;
2947 /* XXXX Should we tp_init or tp_new our basetype? */
2948 it->ob_itself = itself;
2949 it->ob_freeit = CFRelease;
2950 return (PyObject *)it;
2951}
2952
2953int CFURLRefObj_Convert(PyObject *v, CFURLRef *p_itself)
2954{
2955
2956 if (v == Py_None) { *p_itself = NULL; return 1; }
2957 /* Check for other CF objects here */
2958
2959 if (!CFURLRefObj_Check(v))
2960 {
2961 PyErr_SetString(PyExc_TypeError, "CFURLRef required");
2962 return 0;
2963 }
2964 *p_itself = ((CFURLRefObject *)v)->ob_itself;
2965 return 1;
2966}
2967
2968static void CFURLRefObj_dealloc(CFURLRefObject *self)
2969{
2970 if (self->ob_freeit && self->ob_itself)
2971 {
2972 self->ob_freeit((CFTypeRef)self->ob_itself);
2973 self->ob_itself = NULL;
2974 }
2975 CFTypeRef_Type.tp_dealloc((PyObject *)self);
2976}
2977
2978static PyObject *CFURLRefObj_CFURLCreateData(CFURLRefObject *_self, PyObject *_args)
2979{
2980 PyObject *_res = NULL;
2981 CFDataRef _rv;
2982 CFStringEncoding encoding;
2983 Boolean escapeWhitespace;
2984 if (!PyArg_ParseTuple(_args, "ll",
2985 &encoding,
2986 &escapeWhitespace))
2987 return NULL;
2988 _rv = CFURLCreateData((CFAllocatorRef)NULL,
2989 _self->ob_itself,
2990 encoding,
2991 escapeWhitespace);
2992 _res = Py_BuildValue("O&",
2993 CFDataRefObj_New, _rv);
2994 return _res;
2995}
2996
2997static PyObject *CFURLRefObj_CFURLGetFileSystemRepresentation(CFURLRefObject *_self, PyObject *_args)
2998{
2999 PyObject *_res = NULL;
3000 Boolean _rv;
3001 Boolean resolveAgainstBase;
3002 UInt8 buffer;
3003 CFIndex maxBufLen;
3004#ifndef CFURLGetFileSystemRepresentation
3005 PyMac_PRECHECK(CFURLGetFileSystemRepresentation);
3006#endif
3007 if (!PyArg_ParseTuple(_args, "ll",
3008 &resolveAgainstBase,
3009 &maxBufLen))
3010 return NULL;
3011 _rv = CFURLGetFileSystemRepresentation(_self->ob_itself,
3012 resolveAgainstBase,
3013 &buffer,
3014 maxBufLen);
3015 _res = Py_BuildValue("lb",
3016 _rv,
3017 buffer);
3018 return _res;
3019}
3020
3021static PyObject *CFURLRefObj_CFURLCopyAbsoluteURL(CFURLRefObject *_self, PyObject *_args)
3022{
3023 PyObject *_res = NULL;
3024 CFURLRef _rv;
3025#ifndef CFURLCopyAbsoluteURL
3026 PyMac_PRECHECK(CFURLCopyAbsoluteURL);
3027#endif
3028 if (!PyArg_ParseTuple(_args, ""))
3029 return NULL;
3030 _rv = CFURLCopyAbsoluteURL(_self->ob_itself);
3031 _res = Py_BuildValue("O&",
3032 CFURLRefObj_New, _rv);
3033 return _res;
3034}
3035
3036static PyObject *CFURLRefObj_CFURLGetString(CFURLRefObject *_self, PyObject *_args)
3037{
3038 PyObject *_res = NULL;
3039 CFStringRef _rv;
3040#ifndef CFURLGetString
3041 PyMac_PRECHECK(CFURLGetString);
3042#endif
3043 if (!PyArg_ParseTuple(_args, ""))
3044 return NULL;
3045 _rv = CFURLGetString(_self->ob_itself);
3046 _res = Py_BuildValue("O&",
3047 CFStringRefObj_New, _rv);
3048 return _res;
3049}
3050
3051static PyObject *CFURLRefObj_CFURLGetBaseURL(CFURLRefObject *_self, PyObject *_args)
3052{
3053 PyObject *_res = NULL;
3054 CFURLRef _rv;
3055#ifndef CFURLGetBaseURL
3056 PyMac_PRECHECK(CFURLGetBaseURL);
3057#endif
3058 if (!PyArg_ParseTuple(_args, ""))
3059 return NULL;
3060 _rv = CFURLGetBaseURL(_self->ob_itself);
3061 _res = Py_BuildValue("O&",
3062 CFURLRefObj_New, _rv);
3063 return _res;
3064}
3065
3066static PyObject *CFURLRefObj_CFURLCanBeDecomposed(CFURLRefObject *_self, PyObject *_args)
3067{
3068 PyObject *_res = NULL;
3069 Boolean _rv;
3070#ifndef CFURLCanBeDecomposed
3071 PyMac_PRECHECK(CFURLCanBeDecomposed);
3072#endif
3073 if (!PyArg_ParseTuple(_args, ""))
3074 return NULL;
3075 _rv = CFURLCanBeDecomposed(_self->ob_itself);
3076 _res = Py_BuildValue("l",
3077 _rv);
3078 return _res;
3079}
3080
3081static PyObject *CFURLRefObj_CFURLCopyScheme(CFURLRefObject *_self, PyObject *_args)
3082{
3083 PyObject *_res = NULL;
3084 CFStringRef _rv;
3085#ifndef CFURLCopyScheme
3086 PyMac_PRECHECK(CFURLCopyScheme);
3087#endif
3088 if (!PyArg_ParseTuple(_args, ""))
3089 return NULL;
3090 _rv = CFURLCopyScheme(_self->ob_itself);
3091 _res = Py_BuildValue("O&",
3092 CFStringRefObj_New, _rv);
3093 return _res;
3094}
3095
3096static PyObject *CFURLRefObj_CFURLCopyNetLocation(CFURLRefObject *_self, PyObject *_args)
3097{
3098 PyObject *_res = NULL;
3099 CFStringRef _rv;
3100#ifndef CFURLCopyNetLocation
3101 PyMac_PRECHECK(CFURLCopyNetLocation);
3102#endif
3103 if (!PyArg_ParseTuple(_args, ""))
3104 return NULL;
3105 _rv = CFURLCopyNetLocation(_self->ob_itself);
3106 _res = Py_BuildValue("O&",
3107 CFStringRefObj_New, _rv);
3108 return _res;
3109}
3110
3111static PyObject *CFURLRefObj_CFURLCopyPath(CFURLRefObject *_self, PyObject *_args)
3112{
3113 PyObject *_res = NULL;
3114 CFStringRef _rv;
3115#ifndef CFURLCopyPath
3116 PyMac_PRECHECK(CFURLCopyPath);
3117#endif
3118 if (!PyArg_ParseTuple(_args, ""))
3119 return NULL;
3120 _rv = CFURLCopyPath(_self->ob_itself);
3121 _res = Py_BuildValue("O&",
3122 CFStringRefObj_New, _rv);
3123 return _res;
3124}
3125
3126static PyObject *CFURLRefObj_CFURLCopyStrictPath(CFURLRefObject *_self, PyObject *_args)
3127{
3128 PyObject *_res = NULL;
3129 CFStringRef _rv;
3130 Boolean isAbsolute;
3131#ifndef CFURLCopyStrictPath
3132 PyMac_PRECHECK(CFURLCopyStrictPath);
3133#endif
3134 if (!PyArg_ParseTuple(_args, ""))
3135 return NULL;
3136 _rv = CFURLCopyStrictPath(_self->ob_itself,
3137 &isAbsolute);
3138 _res = Py_BuildValue("O&l",
3139 CFStringRefObj_New, _rv,
3140 isAbsolute);
3141 return _res;
3142}
3143
3144static PyObject *CFURLRefObj_CFURLCopyFileSystemPath(CFURLRefObject *_self, PyObject *_args)
3145{
3146 PyObject *_res = NULL;
3147 CFStringRef _rv;
3148 CFURLPathStyle pathStyle;
3149#ifndef CFURLCopyFileSystemPath
3150 PyMac_PRECHECK(CFURLCopyFileSystemPath);
3151#endif
3152 if (!PyArg_ParseTuple(_args, "l",
3153 &pathStyle))
3154 return NULL;
3155 _rv = CFURLCopyFileSystemPath(_self->ob_itself,
3156 pathStyle);
3157 _res = Py_BuildValue("O&",
3158 CFStringRefObj_New, _rv);
3159 return _res;
3160}
3161
3162static PyObject *CFURLRefObj_CFURLHasDirectoryPath(CFURLRefObject *_self, PyObject *_args)
3163{
3164 PyObject *_res = NULL;
3165 Boolean _rv;
3166#ifndef CFURLHasDirectoryPath
3167 PyMac_PRECHECK(CFURLHasDirectoryPath);
3168#endif
3169 if (!PyArg_ParseTuple(_args, ""))
3170 return NULL;
3171 _rv = CFURLHasDirectoryPath(_self->ob_itself);
3172 _res = Py_BuildValue("l",
3173 _rv);
3174 return _res;
3175}
3176
3177static PyObject *CFURLRefObj_CFURLCopyResourceSpecifier(CFURLRefObject *_self, PyObject *_args)
3178{
3179 PyObject *_res = NULL;
3180 CFStringRef _rv;
3181#ifndef CFURLCopyResourceSpecifier
3182 PyMac_PRECHECK(CFURLCopyResourceSpecifier);
3183#endif
3184 if (!PyArg_ParseTuple(_args, ""))
3185 return NULL;
3186 _rv = CFURLCopyResourceSpecifier(_self->ob_itself);
3187 _res = Py_BuildValue("O&",
3188 CFStringRefObj_New, _rv);
3189 return _res;
3190}
3191
3192static PyObject *CFURLRefObj_CFURLCopyHostName(CFURLRefObject *_self, PyObject *_args)
3193{
3194 PyObject *_res = NULL;
3195 CFStringRef _rv;
3196#ifndef CFURLCopyHostName
3197 PyMac_PRECHECK(CFURLCopyHostName);
3198#endif
3199 if (!PyArg_ParseTuple(_args, ""))
3200 return NULL;
3201 _rv = CFURLCopyHostName(_self->ob_itself);
3202 _res = Py_BuildValue("O&",
3203 CFStringRefObj_New, _rv);
3204 return _res;
3205}
3206
3207static PyObject *CFURLRefObj_CFURLGetPortNumber(CFURLRefObject *_self, PyObject *_args)
3208{
3209 PyObject *_res = NULL;
3210 SInt32 _rv;
3211#ifndef CFURLGetPortNumber
3212 PyMac_PRECHECK(CFURLGetPortNumber);
3213#endif
3214 if (!PyArg_ParseTuple(_args, ""))
3215 return NULL;
3216 _rv = CFURLGetPortNumber(_self->ob_itself);
3217 _res = Py_BuildValue("l",
3218 _rv);
3219 return _res;
3220}
3221
3222static PyObject *CFURLRefObj_CFURLCopyUserName(CFURLRefObject *_self, PyObject *_args)
3223{
3224 PyObject *_res = NULL;
3225 CFStringRef _rv;
3226#ifndef CFURLCopyUserName
3227 PyMac_PRECHECK(CFURLCopyUserName);
3228#endif
3229 if (!PyArg_ParseTuple(_args, ""))
3230 return NULL;
3231 _rv = CFURLCopyUserName(_self->ob_itself);
3232 _res = Py_BuildValue("O&",
3233 CFStringRefObj_New, _rv);
3234 return _res;
3235}
3236
3237static PyObject *CFURLRefObj_CFURLCopyPassword(CFURLRefObject *_self, PyObject *_args)
3238{
3239 PyObject *_res = NULL;
3240 CFStringRef _rv;
3241#ifndef CFURLCopyPassword
3242 PyMac_PRECHECK(CFURLCopyPassword);
3243#endif
3244 if (!PyArg_ParseTuple(_args, ""))
3245 return NULL;
3246 _rv = CFURLCopyPassword(_self->ob_itself);
3247 _res = Py_BuildValue("O&",
3248 CFStringRefObj_New, _rv);
3249 return _res;
3250}
3251
3252static PyObject *CFURLRefObj_CFURLCopyParameterString(CFURLRefObject *_self, PyObject *_args)
3253{
3254 PyObject *_res = NULL;
3255 CFStringRef _rv;
3256 CFStringRef charactersToLeaveEscaped;
3257#ifndef CFURLCopyParameterString
3258 PyMac_PRECHECK(CFURLCopyParameterString);
3259#endif
3260 if (!PyArg_ParseTuple(_args, "O&",
3261 CFStringRefObj_Convert, &charactersToLeaveEscaped))
3262 return NULL;
3263 _rv = CFURLCopyParameterString(_self->ob_itself,
3264 charactersToLeaveEscaped);
3265 _res = Py_BuildValue("O&",
3266 CFStringRefObj_New, _rv);
3267 return _res;
3268}
3269
3270static PyObject *CFURLRefObj_CFURLCopyQueryString(CFURLRefObject *_self, PyObject *_args)
3271{
3272 PyObject *_res = NULL;
3273 CFStringRef _rv;
3274 CFStringRef charactersToLeaveEscaped;
3275#ifndef CFURLCopyQueryString
3276 PyMac_PRECHECK(CFURLCopyQueryString);
3277#endif
3278 if (!PyArg_ParseTuple(_args, "O&",
3279 CFStringRefObj_Convert, &charactersToLeaveEscaped))
3280 return NULL;
3281 _rv = CFURLCopyQueryString(_self->ob_itself,
3282 charactersToLeaveEscaped);
3283 _res = Py_BuildValue("O&",
3284 CFStringRefObj_New, _rv);
3285 return _res;
3286}
3287
3288static PyObject *CFURLRefObj_CFURLCopyFragment(CFURLRefObject *_self, PyObject *_args)
3289{
3290 PyObject *_res = NULL;
3291 CFStringRef _rv;
3292 CFStringRef charactersToLeaveEscaped;
3293#ifndef CFURLCopyFragment
3294 PyMac_PRECHECK(CFURLCopyFragment);
3295#endif
3296 if (!PyArg_ParseTuple(_args, "O&",
3297 CFStringRefObj_Convert, &charactersToLeaveEscaped))
3298 return NULL;
3299 _rv = CFURLCopyFragment(_self->ob_itself,
3300 charactersToLeaveEscaped);
3301 _res = Py_BuildValue("O&",
3302 CFStringRefObj_New, _rv);
3303 return _res;
3304}
3305
3306static PyObject *CFURLRefObj_CFURLCopyLastPathComponent(CFURLRefObject *_self, PyObject *_args)
3307{
3308 PyObject *_res = NULL;
3309 CFStringRef _rv;
3310#ifndef CFURLCopyLastPathComponent
3311 PyMac_PRECHECK(CFURLCopyLastPathComponent);
3312#endif
3313 if (!PyArg_ParseTuple(_args, ""))
3314 return NULL;
3315 _rv = CFURLCopyLastPathComponent(_self->ob_itself);
3316 _res = Py_BuildValue("O&",
3317 CFStringRefObj_New, _rv);
3318 return _res;
3319}
3320
3321static PyObject *CFURLRefObj_CFURLCopyPathExtension(CFURLRefObject *_self, PyObject *_args)
3322{
3323 PyObject *_res = NULL;
3324 CFStringRef _rv;
3325#ifndef CFURLCopyPathExtension
3326 PyMac_PRECHECK(CFURLCopyPathExtension);
3327#endif
3328 if (!PyArg_ParseTuple(_args, ""))
3329 return NULL;
3330 _rv = CFURLCopyPathExtension(_self->ob_itself);
3331 _res = Py_BuildValue("O&",
3332 CFStringRefObj_New, _rv);
3333 return _res;
3334}
3335
3336static PyObject *CFURLRefObj_CFURLCreateCopyAppendingPathComponent(CFURLRefObject *_self, PyObject *_args)
3337{
3338 PyObject *_res = NULL;
3339 CFURLRef _rv;
3340 CFStringRef pathComponent;
3341 Boolean isDirectory;
3342 if (!PyArg_ParseTuple(_args, "O&l",
3343 CFStringRefObj_Convert, &pathComponent,
3344 &isDirectory))
3345 return NULL;
3346 _rv = CFURLCreateCopyAppendingPathComponent((CFAllocatorRef)NULL,
3347 _self->ob_itself,
3348 pathComponent,
3349 isDirectory);
3350 _res = Py_BuildValue("O&",
3351 CFURLRefObj_New, _rv);
3352 return _res;
3353}
3354
3355static PyObject *CFURLRefObj_CFURLCreateCopyDeletingLastPathComponent(CFURLRefObject *_self, PyObject *_args)
3356{
3357 PyObject *_res = NULL;
3358 CFURLRef _rv;
3359 if (!PyArg_ParseTuple(_args, ""))
3360 return NULL;
3361 _rv = CFURLCreateCopyDeletingLastPathComponent((CFAllocatorRef)NULL,
3362 _self->ob_itself);
3363 _res = Py_BuildValue("O&",
3364 CFURLRefObj_New, _rv);
3365 return _res;
3366}
3367
3368static PyObject *CFURLRefObj_CFURLCreateCopyAppendingPathExtension(CFURLRefObject *_self, PyObject *_args)
3369{
3370 PyObject *_res = NULL;
3371 CFURLRef _rv;
3372 CFStringRef extension;
3373 if (!PyArg_ParseTuple(_args, "O&",
3374 CFStringRefObj_Convert, &extension))
3375 return NULL;
3376 _rv = CFURLCreateCopyAppendingPathExtension((CFAllocatorRef)NULL,
3377 _self->ob_itself,
3378 extension);
3379 _res = Py_BuildValue("O&",
3380 CFURLRefObj_New, _rv);
3381 return _res;
3382}
3383
3384static PyObject *CFURLRefObj_CFURLCreateCopyDeletingPathExtension(CFURLRefObject *_self, PyObject *_args)
3385{
3386 PyObject *_res = NULL;
3387 CFURLRef _rv;
3388 if (!PyArg_ParseTuple(_args, ""))
3389 return NULL;
3390 _rv = CFURLCreateCopyDeletingPathExtension((CFAllocatorRef)NULL,
3391 _self->ob_itself);
3392 _res = Py_BuildValue("O&",
3393 CFURLRefObj_New, _rv);
3394 return _res;
3395}
3396
3397static PyObject *CFURLRefObj_CFURLGetFSRef(CFURLRefObject *_self, PyObject *_args)
3398{
3399 PyObject *_res = NULL;
3400 Boolean _rv;
3401 FSRef fsRef;
3402#ifndef CFURLGetFSRef
3403 PyMac_PRECHECK(CFURLGetFSRef);
3404#endif
3405 if (!PyArg_ParseTuple(_args, ""))
3406 return NULL;
3407 _rv = CFURLGetFSRef(_self->ob_itself,
3408 &fsRef);
3409 _res = Py_BuildValue("lO&",
3410 _rv,
3411 PyMac_BuildFSRef, &fsRef);
3412 return _res;
3413}
3414
3415static PyMethodDef CFURLRefObj_methods[] = {
3416 {"CFURLCreateData", (PyCFunction)CFURLRefObj_CFURLCreateData, 1,
3417 PyDoc_STR("(CFStringEncoding encoding, Boolean escapeWhitespace) -> (CFDataRef _rv)")},
3418 {"CFURLGetFileSystemRepresentation", (PyCFunction)CFURLRefObj_CFURLGetFileSystemRepresentation, 1,
3419 PyDoc_STR("(Boolean resolveAgainstBase, CFIndex maxBufLen) -> (Boolean _rv, UInt8 buffer)")},
3420 {"CFURLCopyAbsoluteURL", (PyCFunction)CFURLRefObj_CFURLCopyAbsoluteURL, 1,
3421 PyDoc_STR("() -> (CFURLRef _rv)")},
3422 {"CFURLGetString", (PyCFunction)CFURLRefObj_CFURLGetString, 1,
3423 PyDoc_STR("() -> (CFStringRef _rv)")},
3424 {"CFURLGetBaseURL", (PyCFunction)CFURLRefObj_CFURLGetBaseURL, 1,
3425 PyDoc_STR("() -> (CFURLRef _rv)")},
3426 {"CFURLCanBeDecomposed", (PyCFunction)CFURLRefObj_CFURLCanBeDecomposed, 1,
3427 PyDoc_STR("() -> (Boolean _rv)")},
3428 {"CFURLCopyScheme", (PyCFunction)CFURLRefObj_CFURLCopyScheme, 1,
3429 PyDoc_STR("() -> (CFStringRef _rv)")},
3430 {"CFURLCopyNetLocation", (PyCFunction)CFURLRefObj_CFURLCopyNetLocation, 1,
3431 PyDoc_STR("() -> (CFStringRef _rv)")},
3432 {"CFURLCopyPath", (PyCFunction)CFURLRefObj_CFURLCopyPath, 1,
3433 PyDoc_STR("() -> (CFStringRef _rv)")},
3434 {"CFURLCopyStrictPath", (PyCFunction)CFURLRefObj_CFURLCopyStrictPath, 1,
3435 PyDoc_STR("() -> (CFStringRef _rv, Boolean isAbsolute)")},
3436 {"CFURLCopyFileSystemPath", (PyCFunction)CFURLRefObj_CFURLCopyFileSystemPath, 1,
3437 PyDoc_STR("(CFURLPathStyle pathStyle) -> (CFStringRef _rv)")},
3438 {"CFURLHasDirectoryPath", (PyCFunction)CFURLRefObj_CFURLHasDirectoryPath, 1,
3439 PyDoc_STR("() -> (Boolean _rv)")},
3440 {"CFURLCopyResourceSpecifier", (PyCFunction)CFURLRefObj_CFURLCopyResourceSpecifier, 1,
3441 PyDoc_STR("() -> (CFStringRef _rv)")},
3442 {"CFURLCopyHostName", (PyCFunction)CFURLRefObj_CFURLCopyHostName, 1,
3443 PyDoc_STR("() -> (CFStringRef _rv)")},
3444 {"CFURLGetPortNumber", (PyCFunction)CFURLRefObj_CFURLGetPortNumber, 1,
3445 PyDoc_STR("() -> (SInt32 _rv)")},
3446 {"CFURLCopyUserName", (PyCFunction)CFURLRefObj_CFURLCopyUserName, 1,
3447 PyDoc_STR("() -> (CFStringRef _rv)")},
3448 {"CFURLCopyPassword", (PyCFunction)CFURLRefObj_CFURLCopyPassword, 1,
3449 PyDoc_STR("() -> (CFStringRef _rv)")},
3450 {"CFURLCopyParameterString", (PyCFunction)CFURLRefObj_CFURLCopyParameterString, 1,
3451 PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")},
3452 {"CFURLCopyQueryString", (PyCFunction)CFURLRefObj_CFURLCopyQueryString, 1,
3453 PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")},
3454 {"CFURLCopyFragment", (PyCFunction)CFURLRefObj_CFURLCopyFragment, 1,
3455 PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")},
3456 {"CFURLCopyLastPathComponent", (PyCFunction)CFURLRefObj_CFURLCopyLastPathComponent, 1,
3457 PyDoc_STR("() -> (CFStringRef _rv)")},
3458 {"CFURLCopyPathExtension", (PyCFunction)CFURLRefObj_CFURLCopyPathExtension, 1,
3459 PyDoc_STR("() -> (CFStringRef _rv)")},
3460 {"CFURLCreateCopyAppendingPathComponent", (PyCFunction)CFURLRefObj_CFURLCreateCopyAppendingPathComponent, 1,
3461 PyDoc_STR("(CFStringRef pathComponent, Boolean isDirectory) -> (CFURLRef _rv)")},
3462 {"CFURLCreateCopyDeletingLastPathComponent", (PyCFunction)CFURLRefObj_CFURLCreateCopyDeletingLastPathComponent, 1,
3463 PyDoc_STR("() -> (CFURLRef _rv)")},
3464 {"CFURLCreateCopyAppendingPathExtension", (PyCFunction)CFURLRefObj_CFURLCreateCopyAppendingPathExtension, 1,
3465 PyDoc_STR("(CFStringRef extension) -> (CFURLRef _rv)")},
3466 {"CFURLCreateCopyDeletingPathExtension", (PyCFunction)CFURLRefObj_CFURLCreateCopyDeletingPathExtension, 1,
3467 PyDoc_STR("() -> (CFURLRef _rv)")},
3468 {"CFURLGetFSRef", (PyCFunction)CFURLRefObj_CFURLGetFSRef, 1,
3469 PyDoc_STR("() -> (Boolean _rv, FSRef fsRef)")},
3470 {NULL, NULL, 0}
3471};
3472
3473#define CFURLRefObj_getsetlist NULL
3474
3475
3476static int CFURLRefObj_compare(CFURLRefObject *self, CFURLRefObject *other)
3477{
3478 /* XXXX Or should we use CFEqual?? */
3479 if ( self->ob_itself > other->ob_itself ) return 1;
3480 if ( self->ob_itself < other->ob_itself ) return -1;
3481 return 0;
3482}
3483
3484static PyObject * CFURLRefObj_repr(CFURLRefObject *self)
3485{
3486 char buf[100];
3487 sprintf(buf, "<CFURL object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
3488 return PyString_FromString(buf);
3489}
3490
3491static int CFURLRefObj_hash(CFURLRefObject *self)
3492{
3493 /* XXXX Or should we use CFHash?? */
3494 return (int)self->ob_itself;
3495}
3496static int CFURLRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)
3497{
3498 CFURLRef itself;
3499 char *kw[] = {"itself", 0};
3500
3501 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFURLRefObj_Convert, &itself))
3502 {
3503 ((CFURLRefObject *)_self)->ob_itself = itself;
3504 return 0;
3505 }
3506
3507 /* Any CFTypeRef descendent is allowed as initializer too */
3508 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself))
3509 {
3510 ((CFURLRefObject *)_self)->ob_itself = itself;
3511 return 0;
3512 }
3513 return -1;
3514}
3515
3516#define CFURLRefObj_tp_alloc PyType_GenericAlloc
3517
3518static PyObject *CFURLRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
3519{
3520 PyObject *self;
3521 if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;
3522 ((CFURLRefObject *)self)->ob_itself = NULL;
3523 ((CFURLRefObject *)self)->ob_freeit = CFRelease;
3524 return self;
3525}
3526
3527#define CFURLRefObj_tp_free PyObject_Del
3528
3529
3530PyTypeObject CFURLRef_Type = {
3531 PyObject_HEAD_INIT(NULL)
3532 0, /*ob_size*/
3533 "_CF.CFURLRef", /*tp_name*/
3534 sizeof(CFURLRefObject), /*tp_basicsize*/
3535 0, /*tp_itemsize*/
3536 /* methods */
3537 (destructor) CFURLRefObj_dealloc, /*tp_dealloc*/
3538 0, /*tp_print*/
3539 (getattrfunc)0, /*tp_getattr*/
3540 (setattrfunc)0, /*tp_setattr*/
3541 (cmpfunc) CFURLRefObj_compare, /*tp_compare*/
3542 (reprfunc) CFURLRefObj_repr, /*tp_repr*/
3543 (PyNumberMethods *)0, /* tp_as_number */
3544 (PySequenceMethods *)0, /* tp_as_sequence */
3545 (PyMappingMethods *)0, /* tp_as_mapping */
3546 (hashfunc) CFURLRefObj_hash, /*tp_hash*/
3547 0, /*tp_call*/
3548 0, /*tp_str*/
3549 PyObject_GenericGetAttr, /*tp_getattro*/
3550 PyObject_GenericSetAttr, /*tp_setattro */
3551 0, /*tp_as_buffer*/
3552 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
3553 0, /*tp_doc*/
3554 0, /*tp_traverse*/
3555 0, /*tp_clear*/
3556 0, /*tp_richcompare*/
3557 0, /*tp_weaklistoffset*/
3558 0, /*tp_iter*/
3559 0, /*tp_iternext*/
3560 CFURLRefObj_methods, /* tp_methods */
3561 0, /*tp_members*/
3562 CFURLRefObj_getsetlist, /*tp_getset*/
3563 0, /*tp_base*/
3564 0, /*tp_dict*/
3565 0, /*tp_descr_get*/
3566 0, /*tp_descr_set*/
3567 0, /*tp_dictoffset*/
3568 CFURLRefObj_tp_init, /* tp_init */
3569 CFURLRefObj_tp_alloc, /* tp_alloc */
3570 CFURLRefObj_tp_new, /* tp_new */
3571 CFURLRefObj_tp_free, /* tp_free */
3572};
3573
3574/* -------------------- End object type CFURLRef -------------------- */
3575
3576
3577static PyObject *CF___CFRangeMake(PyObject *_self, PyObject *_args)
3578{
3579 PyObject *_res = NULL;
3580 CFRange _rv;
3581 CFIndex loc;
3582 CFIndex len;
3583#ifndef __CFRangeMake
3584 PyMac_PRECHECK(__CFRangeMake);
3585#endif
3586 if (!PyArg_ParseTuple(_args, "ll",
3587 &loc,
3588 &len))
3589 return NULL;
3590 _rv = __CFRangeMake(loc,
3591 len);
3592 _res = Py_BuildValue("O&",
3593 CFRange_New, _rv);
3594 return _res;
3595}
3596
3597static PyObject *CF_CFAllocatorGetTypeID(PyObject *_self, PyObject *_args)
3598{
3599 PyObject *_res = NULL;
3600 CFTypeID _rv;
3601#ifndef CFAllocatorGetTypeID
3602 PyMac_PRECHECK(CFAllocatorGetTypeID);
3603#endif
3604 if (!PyArg_ParseTuple(_args, ""))
3605 return NULL;
3606 _rv = CFAllocatorGetTypeID();
3607 _res = Py_BuildValue("l",
3608 _rv);
3609 return _res;
3610}
3611
3612static PyObject *CF_CFAllocatorGetPreferredSizeForSize(PyObject *_self, PyObject *_args)
3613{
3614 PyObject *_res = NULL;
3615 CFIndex _rv;
3616 CFIndex size;
3617 CFOptionFlags hint;
3618#ifndef CFAllocatorGetPreferredSizeForSize
3619 PyMac_PRECHECK(CFAllocatorGetPreferredSizeForSize);
3620#endif
3621 if (!PyArg_ParseTuple(_args, "ll",
3622 &size,
3623 &hint))
3624 return NULL;
3625 _rv = CFAllocatorGetPreferredSizeForSize((CFAllocatorRef)NULL,
3626 size,
3627 hint);
3628 _res = Py_BuildValue("l",
3629 _rv);
3630 return _res;
3631}
3632
3633static PyObject *CF_CFCopyTypeIDDescription(PyObject *_self, PyObject *_args)
3634{
3635 PyObject *_res = NULL;
3636 CFStringRef _rv;
3637 CFTypeID type_id;
3638#ifndef CFCopyTypeIDDescription
3639 PyMac_PRECHECK(CFCopyTypeIDDescription);
3640#endif
3641 if (!PyArg_ParseTuple(_args, "l",
3642 &type_id))
3643 return NULL;
3644 _rv = CFCopyTypeIDDescription(type_id);
3645 _res = Py_BuildValue("O&",
3646 CFStringRefObj_New, _rv);
3647 return _res;
3648}
3649
3650static PyObject *CF_CFArrayGetTypeID(PyObject *_self, PyObject *_args)
3651{
3652 PyObject *_res = NULL;
3653 CFTypeID _rv;
3654#ifndef CFArrayGetTypeID
3655 PyMac_PRECHECK(CFArrayGetTypeID);
3656#endif
3657 if (!PyArg_ParseTuple(_args, ""))
3658 return NULL;
3659 _rv = CFArrayGetTypeID();
3660 _res = Py_BuildValue("l",
3661 _rv);
3662 return _res;
3663}
3664
3665static PyObject *CF_CFArrayCreateMutable(PyObject *_self, PyObject *_args)
3666{
3667 PyObject *_res = NULL;
3668 CFMutableArrayRef _rv;
3669 CFIndex capacity;
3670#ifndef CFArrayCreateMutable
3671 PyMac_PRECHECK(CFArrayCreateMutable);
3672#endif
3673 if (!PyArg_ParseTuple(_args, "l",
3674 &capacity))
3675 return NULL;
3676 _rv = CFArrayCreateMutable((CFAllocatorRef)NULL,
3677 capacity,
3678 &kCFTypeArrayCallBacks);
3679 _res = Py_BuildValue("O&",
3680 CFMutableArrayRefObj_New, _rv);
3681 return _res;
3682}
3683
3684static PyObject *CF_CFArrayCreateMutableCopy(PyObject *_self, PyObject *_args)
3685{
3686 PyObject *_res = NULL;
3687 CFMutableArrayRef _rv;
3688 CFIndex capacity;
3689 CFArrayRef theArray;
3690#ifndef CFArrayCreateMutableCopy
3691 PyMac_PRECHECK(CFArrayCreateMutableCopy);
3692#endif
3693 if (!PyArg_ParseTuple(_args, "lO&",
3694 &capacity,
3695 CFArrayRefObj_Convert, &theArray))
3696 return NULL;
3697 _rv = CFArrayCreateMutableCopy((CFAllocatorRef)NULL,
3698 capacity,
3699 theArray);
3700 _res = Py_BuildValue("O&",
3701 CFMutableArrayRefObj_New, _rv);
3702 return _res;
3703}
3704
3705static PyObject *CF_CFDataGetTypeID(PyObject *_self, PyObject *_args)
3706{
3707 PyObject *_res = NULL;
3708 CFTypeID _rv;
3709#ifndef CFDataGetTypeID
3710 PyMac_PRECHECK(CFDataGetTypeID);
3711#endif
3712 if (!PyArg_ParseTuple(_args, ""))
3713 return NULL;
3714 _rv = CFDataGetTypeID();
3715 _res = Py_BuildValue("l",
3716 _rv);
3717 return _res;
3718}
3719
3720static PyObject *CF_CFDataCreate(PyObject *_self, PyObject *_args)
3721{
3722 PyObject *_res = NULL;
3723 CFDataRef _rv;
3724 unsigned char *bytes__in__;
3725 long bytes__len__;
3726 int bytes__in_len__;
3727#ifndef CFDataCreate
3728 PyMac_PRECHECK(CFDataCreate);
3729#endif
3730 if (!PyArg_ParseTuple(_args, "s#",
3731 &bytes__in__, &bytes__in_len__))
3732 return NULL;
3733 bytes__len__ = bytes__in_len__;
3734 _rv = CFDataCreate((CFAllocatorRef)NULL,
3735 bytes__in__, bytes__len__);
3736 _res = Py_BuildValue("O&",
3737 CFDataRefObj_New, _rv);
3738 return _res;
3739}
3740
3741static PyObject *CF_CFDataCreateWithBytesNoCopy(PyObject *_self, PyObject *_args)
3742{
3743 PyObject *_res = NULL;
3744 CFDataRef _rv;
3745 unsigned char *bytes__in__;
3746 long bytes__len__;
3747 int bytes__in_len__;
3748#ifndef CFDataCreateWithBytesNoCopy
3749 PyMac_PRECHECK(CFDataCreateWithBytesNoCopy);
3750#endif
3751 if (!PyArg_ParseTuple(_args, "s#",
3752 &bytes__in__, &bytes__in_len__))
3753 return NULL;
3754 bytes__len__ = bytes__in_len__;
3755 _rv = CFDataCreateWithBytesNoCopy((CFAllocatorRef)NULL,
3756 bytes__in__, bytes__len__,
3757 (CFAllocatorRef)NULL);
3758 _res = Py_BuildValue("O&",
3759 CFDataRefObj_New, _rv);
3760 return _res;
3761}
3762
3763static PyObject *CF_CFDataCreateMutable(PyObject *_self, PyObject *_args)
3764{
3765 PyObject *_res = NULL;
3766 CFMutableDataRef _rv;
3767 CFIndex capacity;
3768#ifndef CFDataCreateMutable
3769 PyMac_PRECHECK(CFDataCreateMutable);
3770#endif
3771 if (!PyArg_ParseTuple(_args, "l",
3772 &capacity))
3773 return NULL;
3774 _rv = CFDataCreateMutable((CFAllocatorRef)NULL,
3775 capacity);
3776 _res = Py_BuildValue("O&",
3777 CFMutableDataRefObj_New, _rv);
3778 return _res;
3779}
3780
3781static PyObject *CF_CFDataCreateMutableCopy(PyObject *_self, PyObject *_args)
3782{
3783 PyObject *_res = NULL;
3784 CFMutableDataRef _rv;
3785 CFIndex capacity;
3786 CFDataRef theData;
3787#ifndef CFDataCreateMutableCopy
3788 PyMac_PRECHECK(CFDataCreateMutableCopy);
3789#endif
3790 if (!PyArg_ParseTuple(_args, "lO&",
3791 &capacity,
3792 CFDataRefObj_Convert, &theData))
3793 return NULL;
3794 _rv = CFDataCreateMutableCopy((CFAllocatorRef)NULL,
3795 capacity,
3796 theData);
3797 _res = Py_BuildValue("O&",
3798 CFMutableDataRefObj_New, _rv);
3799 return _res;
3800}
3801
3802static PyObject *CF_CFDictionaryGetTypeID(PyObject *_self, PyObject *_args)
3803{
3804 PyObject *_res = NULL;
3805 CFTypeID _rv;
3806#ifndef CFDictionaryGetTypeID
3807 PyMac_PRECHECK(CFDictionaryGetTypeID);
3808#endif
3809 if (!PyArg_ParseTuple(_args, ""))
3810 return NULL;
3811 _rv = CFDictionaryGetTypeID();
3812 _res = Py_BuildValue("l",
3813 _rv);
3814 return _res;
3815}
3816
3817static PyObject *CF_CFDictionaryCreateMutable(PyObject *_self, PyObject *_args)
3818{
3819 PyObject *_res = NULL;
3820 CFMutableDictionaryRef _rv;
3821 CFIndex capacity;
3822#ifndef CFDictionaryCreateMutable
3823 PyMac_PRECHECK(CFDictionaryCreateMutable);
3824#endif
3825 if (!PyArg_ParseTuple(_args, "l",
3826 &capacity))
3827 return NULL;
3828 _rv = CFDictionaryCreateMutable((CFAllocatorRef)NULL,
3829 capacity,
3830 &kCFTypeDictionaryKeyCallBacks,
3831 &kCFTypeDictionaryValueCallBacks);
3832 _res = Py_BuildValue("O&",
3833 CFMutableDictionaryRefObj_New, _rv);
3834 return _res;
3835}
3836
3837static PyObject *CF_CFDictionaryCreateMutableCopy(PyObject *_self, PyObject *_args)
3838{
3839 PyObject *_res = NULL;
3840 CFMutableDictionaryRef _rv;
3841 CFIndex capacity;
3842 CFDictionaryRef theDict;
3843#ifndef CFDictionaryCreateMutableCopy
3844 PyMac_PRECHECK(CFDictionaryCreateMutableCopy);
3845#endif
3846 if (!PyArg_ParseTuple(_args, "lO&",
3847 &capacity,
3848 CFDictionaryRefObj_Convert, &theDict))
3849 return NULL;
3850 _rv = CFDictionaryCreateMutableCopy((CFAllocatorRef)NULL,
3851 capacity,
3852 theDict);
3853 _res = Py_BuildValue("O&",
3854 CFMutableDictionaryRefObj_New, _rv);
3855 return _res;
3856}
3857
3858static PyObject *CF_CFPreferencesCopyAppValue(PyObject *_self, PyObject *_args)
3859{
3860 PyObject *_res = NULL;
3861 CFTypeRef _rv;
3862 CFStringRef key;
3863 CFStringRef applicationID;
3864#ifndef CFPreferencesCopyAppValue
3865 PyMac_PRECHECK(CFPreferencesCopyAppValue);
3866#endif
3867 if (!PyArg_ParseTuple(_args, "O&O&",
3868 CFStringRefObj_Convert, &key,
3869 CFStringRefObj_Convert, &applicationID))
3870 return NULL;
3871 _rv = CFPreferencesCopyAppValue(key,
3872 applicationID);
3873 _res = Py_BuildValue("O&",
3874 CFTypeRefObj_New, _rv);
3875 return _res;
3876}
3877
3878static PyObject *CF_CFPreferencesGetAppBooleanValue(PyObject *_self, PyObject *_args)
3879{
3880 PyObject *_res = NULL;
3881 Boolean _rv;
3882 CFStringRef key;
3883 CFStringRef applicationID;
3884 Boolean keyExistsAndHasValidFormat;
3885#ifndef CFPreferencesGetAppBooleanValue
3886 PyMac_PRECHECK(CFPreferencesGetAppBooleanValue);
3887#endif
3888 if (!PyArg_ParseTuple(_args, "O&O&",
3889 CFStringRefObj_Convert, &key,
3890 CFStringRefObj_Convert, &applicationID))
3891 return NULL;
3892 _rv = CFPreferencesGetAppBooleanValue(key,
3893 applicationID,
3894 &keyExistsAndHasValidFormat);
3895 _res = Py_BuildValue("ll",
3896 _rv,
3897 keyExistsAndHasValidFormat);
3898 return _res;
3899}
3900
3901static PyObject *CF_CFPreferencesGetAppIntegerValue(PyObject *_self, PyObject *_args)
3902{
3903 PyObject *_res = NULL;
3904 CFIndex _rv;
3905 CFStringRef key;
3906 CFStringRef applicationID;
3907 Boolean keyExistsAndHasValidFormat;
3908#ifndef CFPreferencesGetAppIntegerValue
3909 PyMac_PRECHECK(CFPreferencesGetAppIntegerValue);
3910#endif
3911 if (!PyArg_ParseTuple(_args, "O&O&",
3912 CFStringRefObj_Convert, &key,
3913 CFStringRefObj_Convert, &applicationID))
3914 return NULL;
3915 _rv = CFPreferencesGetAppIntegerValue(key,
3916 applicationID,
3917 &keyExistsAndHasValidFormat);
3918 _res = Py_BuildValue("ll",
3919 _rv,
3920 keyExistsAndHasValidFormat);
3921 return _res;
3922}
3923
3924static PyObject *CF_CFPreferencesSetAppValue(PyObject *_self, PyObject *_args)
3925{
3926 PyObject *_res = NULL;
3927 CFStringRef key;
3928 CFTypeRef value;
3929 CFStringRef applicationID;
3930#ifndef CFPreferencesSetAppValue
3931 PyMac_PRECHECK(CFPreferencesSetAppValue);
3932#endif
3933 if (!PyArg_ParseTuple(_args, "O&O&O&",
3934 CFStringRefObj_Convert, &key,
3935 CFTypeRefObj_Convert, &value,
3936 CFStringRefObj_Convert, &applicationID))
3937 return NULL;
3938 CFPreferencesSetAppValue(key,
3939 value,
3940 applicationID);
3941 Py_INCREF(Py_None);
3942 _res = Py_None;
3943 return _res;
3944}
3945
3946static PyObject *CF_CFPreferencesAddSuitePreferencesToApp(PyObject *_self, PyObject *_args)
3947{
3948 PyObject *_res = NULL;
3949 CFStringRef applicationID;
3950 CFStringRef suiteID;
3951#ifndef CFPreferencesAddSuitePreferencesToApp
3952 PyMac_PRECHECK(CFPreferencesAddSuitePreferencesToApp);
3953#endif
3954 if (!PyArg_ParseTuple(_args, "O&O&",
3955 CFStringRefObj_Convert, &applicationID,
3956 CFStringRefObj_Convert, &suiteID))
3957 return NULL;
3958 CFPreferencesAddSuitePreferencesToApp(applicationID,
3959 suiteID);
3960 Py_INCREF(Py_None);
3961 _res = Py_None;
3962 return _res;
3963}
3964
3965static PyObject *CF_CFPreferencesRemoveSuitePreferencesFromApp(PyObject *_self, PyObject *_args)
3966{
3967 PyObject *_res = NULL;
3968 CFStringRef applicationID;
3969 CFStringRef suiteID;
3970#ifndef CFPreferencesRemoveSuitePreferencesFromApp
3971 PyMac_PRECHECK(CFPreferencesRemoveSuitePreferencesFromApp);
3972#endif
3973 if (!PyArg_ParseTuple(_args, "O&O&",
3974 CFStringRefObj_Convert, &applicationID,
3975 CFStringRefObj_Convert, &suiteID))
3976 return NULL;
3977 CFPreferencesRemoveSuitePreferencesFromApp(applicationID,
3978 suiteID);
3979 Py_INCREF(Py_None);
3980 _res = Py_None;
3981 return _res;
3982}
3983
3984static PyObject *CF_CFPreferencesAppSynchronize(PyObject *_self, PyObject *_args)
3985{
3986 PyObject *_res = NULL;
3987 Boolean _rv;
3988 CFStringRef applicationID;
3989#ifndef CFPreferencesAppSynchronize
3990 PyMac_PRECHECK(CFPreferencesAppSynchronize);
3991#endif
3992 if (!PyArg_ParseTuple(_args, "O&",
3993 CFStringRefObj_Convert, &applicationID))
3994 return NULL;
3995 _rv = CFPreferencesAppSynchronize(applicationID);
3996 _res = Py_BuildValue("l",
3997 _rv);
3998 return _res;
3999}
4000
4001static PyObject *CF_CFPreferencesCopyValue(PyObject *_self, PyObject *_args)
4002{
4003 PyObject *_res = NULL;
4004 CFTypeRef _rv;
4005 CFStringRef key;
4006 CFStringRef applicationID;
4007 CFStringRef userName;
4008 CFStringRef hostName;
4009#ifndef CFPreferencesCopyValue
4010 PyMac_PRECHECK(CFPreferencesCopyValue);
4011#endif
4012 if (!PyArg_ParseTuple(_args, "O&O&O&O&",
4013 CFStringRefObj_Convert, &key,
4014 CFStringRefObj_Convert, &applicationID,
4015 CFStringRefObj_Convert, &userName,
4016 CFStringRefObj_Convert, &hostName))
4017 return NULL;
4018 _rv = CFPreferencesCopyValue(key,
4019 applicationID,
4020 userName,
4021 hostName);
4022 _res = Py_BuildValue("O&",
4023 CFTypeRefObj_New, _rv);
4024 return _res;
4025}
4026
4027static PyObject *CF_CFPreferencesCopyMultiple(PyObject *_self, PyObject *_args)
4028{
4029 PyObject *_res = NULL;
4030 CFDictionaryRef _rv;
4031 CFArrayRef keysToFetch;
4032 CFStringRef applicationID;
4033 CFStringRef userName;
4034 CFStringRef hostName;
4035#ifndef CFPreferencesCopyMultiple
4036 PyMac_PRECHECK(CFPreferencesCopyMultiple);
4037#endif
4038 if (!PyArg_ParseTuple(_args, "O&O&O&O&",
4039 CFArrayRefObj_Convert, &keysToFetch,
4040 CFStringRefObj_Convert, &applicationID,
4041 CFStringRefObj_Convert, &userName,
4042 CFStringRefObj_Convert, &hostName))
4043 return NULL;
4044 _rv = CFPreferencesCopyMultiple(keysToFetch,
4045 applicationID,
4046 userName,
4047 hostName);
4048 _res = Py_BuildValue("O&",
4049 CFDictionaryRefObj_New, _rv);
4050 return _res;
4051}
4052
4053static PyObject *CF_CFPreferencesSetValue(PyObject *_self, PyObject *_args)
4054{
4055 PyObject *_res = NULL;
4056 CFStringRef key;
4057 CFTypeRef value;
4058 CFStringRef applicationID;
4059 CFStringRef userName;
4060 CFStringRef hostName;
4061#ifndef CFPreferencesSetValue
4062 PyMac_PRECHECK(CFPreferencesSetValue);
4063#endif
4064 if (!PyArg_ParseTuple(_args, "O&O&O&O&O&",
4065 CFStringRefObj_Convert, &key,
4066 CFTypeRefObj_Convert, &value,
4067 CFStringRefObj_Convert, &applicationID,
4068 CFStringRefObj_Convert, &userName,
4069 CFStringRefObj_Convert, &hostName))
4070 return NULL;
4071 CFPreferencesSetValue(key,
4072 value,
4073 applicationID,
4074 userName,
4075 hostName);
4076 Py_INCREF(Py_None);
4077 _res = Py_None;
4078 return _res;
4079}
4080
4081static PyObject *CF_CFPreferencesSetMultiple(PyObject *_self, PyObject *_args)
4082{
4083 PyObject *_res = NULL;
4084 CFDictionaryRef keysToSet;
4085 CFArrayRef keysToRemove;
4086 CFStringRef applicationID;
4087 CFStringRef userName;
4088 CFStringRef hostName;
4089#ifndef CFPreferencesSetMultiple
4090 PyMac_PRECHECK(CFPreferencesSetMultiple);
4091#endif
4092 if (!PyArg_ParseTuple(_args, "O&O&O&O&O&",
4093 CFDictionaryRefObj_Convert, &keysToSet,
4094 CFArrayRefObj_Convert, &keysToRemove,
4095 CFStringRefObj_Convert, &applicationID,
4096 CFStringRefObj_Convert, &userName,
4097 CFStringRefObj_Convert, &hostName))
4098 return NULL;
4099 CFPreferencesSetMultiple(keysToSet,
4100 keysToRemove,
4101 applicationID,
4102 userName,
4103 hostName);
4104 Py_INCREF(Py_None);
4105 _res = Py_None;
4106 return _res;
4107}
4108
4109static PyObject *CF_CFPreferencesSynchronize(PyObject *_self, PyObject *_args)
4110{
4111 PyObject *_res = NULL;
4112 Boolean _rv;
4113 CFStringRef applicationID;
4114 CFStringRef userName;
4115 CFStringRef hostName;
4116#ifndef CFPreferencesSynchronize
4117 PyMac_PRECHECK(CFPreferencesSynchronize);
4118#endif
4119 if (!PyArg_ParseTuple(_args, "O&O&O&",
4120 CFStringRefObj_Convert, &applicationID,
4121 CFStringRefObj_Convert, &userName,
4122 CFStringRefObj_Convert, &hostName))
4123 return NULL;
4124 _rv = CFPreferencesSynchronize(applicationID,
4125 userName,
4126 hostName);
4127 _res = Py_BuildValue("l",
4128 _rv);
4129 return _res;
4130}
4131
4132static PyObject *CF_CFPreferencesCopyApplicationList(PyObject *_self, PyObject *_args)
4133{
4134 PyObject *_res = NULL;
4135 CFArrayRef _rv;
4136 CFStringRef userName;
4137 CFStringRef hostName;
4138#ifndef CFPreferencesCopyApplicationList
4139 PyMac_PRECHECK(CFPreferencesCopyApplicationList);
4140#endif
4141 if (!PyArg_ParseTuple(_args, "O&O&",
4142 CFStringRefObj_Convert, &userName,
4143 CFStringRefObj_Convert, &hostName))
4144 return NULL;
4145 _rv = CFPreferencesCopyApplicationList(userName,
4146 hostName);
4147 _res = Py_BuildValue("O&",
4148 CFArrayRefObj_New, _rv);
4149 return _res;
4150}
4151
4152static PyObject *CF_CFPreferencesCopyKeyList(PyObject *_self, PyObject *_args)
4153{
4154 PyObject *_res = NULL;
4155 CFArrayRef _rv;
4156 CFStringRef applicationID;
4157 CFStringRef userName;
4158 CFStringRef hostName;
4159#ifndef CFPreferencesCopyKeyList
4160 PyMac_PRECHECK(CFPreferencesCopyKeyList);
4161#endif
4162 if (!PyArg_ParseTuple(_args, "O&O&O&",
4163 CFStringRefObj_Convert, &applicationID,
4164 CFStringRefObj_Convert, &userName,
4165 CFStringRefObj_Convert, &hostName))
4166 return NULL;
4167 _rv = CFPreferencesCopyKeyList(applicationID,
4168 userName,
4169 hostName);
4170 _res = Py_BuildValue("O&",
4171 CFArrayRefObj_New, _rv);
4172 return _res;
4173}
4174
4175static PyObject *CF_CFStringGetTypeID(PyObject *_self, PyObject *_args)
4176{
4177 PyObject *_res = NULL;
4178 CFTypeID _rv;
4179#ifndef CFStringGetTypeID
4180 PyMac_PRECHECK(CFStringGetTypeID);
4181#endif
4182 if (!PyArg_ParseTuple(_args, ""))
4183 return NULL;
4184 _rv = CFStringGetTypeID();
4185 _res = Py_BuildValue("l",
4186 _rv);
4187 return _res;
4188}
4189
4190static PyObject *CF_CFStringCreateWithPascalString(PyObject *_self, PyObject *_args)
4191{
4192 PyObject *_res = NULL;
4193 CFStringRef _rv;
4194 Str255 pStr;
4195 CFStringEncoding encoding;
4196#ifndef CFStringCreateWithPascalString
4197 PyMac_PRECHECK(CFStringCreateWithPascalString);
4198#endif
4199 if (!PyArg_ParseTuple(_args, "O&l",
4200 PyMac_GetStr255, pStr,
4201 &encoding))
4202 return NULL;
4203 _rv = CFStringCreateWithPascalString((CFAllocatorRef)NULL,
4204 pStr,
4205 encoding);
4206 _res = Py_BuildValue("O&",
4207 CFStringRefObj_New, _rv);
4208 return _res;
4209}
4210
4211static PyObject *CF_CFStringCreateWithCString(PyObject *_self, PyObject *_args)
4212{
4213 PyObject *_res = NULL;
4214 CFStringRef _rv;
4215 char* cStr;
4216 CFStringEncoding encoding;
4217#ifndef CFStringCreateWithCString
4218 PyMac_PRECHECK(CFStringCreateWithCString);
4219#endif
4220 if (!PyArg_ParseTuple(_args, "sl",
4221 &cStr,
4222 &encoding))
4223 return NULL;
4224 _rv = CFStringCreateWithCString((CFAllocatorRef)NULL,
4225 cStr,
4226 encoding);
4227 _res = Py_BuildValue("O&",
4228 CFStringRefObj_New, _rv);
4229 return _res;
4230}
4231
4232static PyObject *CF_CFStringCreateWithCharacters(PyObject *_self, PyObject *_args)
4233{
4234 PyObject *_res = NULL;
4235 CFStringRef _rv;
4236 UniChar *chars__in__;
4237 UniCharCount chars__len__;
4238 int chars__in_len__;
4239#ifndef CFStringCreateWithCharacters
4240 PyMac_PRECHECK(CFStringCreateWithCharacters);
4241#endif
4242 if (!PyArg_ParseTuple(_args, "u#",
4243 &chars__in__, &chars__in_len__))
4244 return NULL;
4245 chars__len__ = chars__in_len__;
4246 _rv = CFStringCreateWithCharacters((CFAllocatorRef)NULL,
4247 chars__in__, chars__len__);
4248 _res = Py_BuildValue("O&",
4249 CFStringRefObj_New, _rv);
4250 return _res;
4251}
4252
4253static PyObject *CF_CFStringCreateWithPascalStringNoCopy(PyObject *_self, PyObject *_args)
4254{
4255 PyObject *_res = NULL;
4256 CFStringRef _rv;
4257 Str255 pStr;
4258 CFStringEncoding encoding;
4259#ifndef CFStringCreateWithPascalStringNoCopy
4260 PyMac_PRECHECK(CFStringCreateWithPascalStringNoCopy);
4261#endif
4262 if (!PyArg_ParseTuple(_args, "O&l",
4263 PyMac_GetStr255, pStr,
4264 &encoding))
4265 return NULL;
4266 _rv = CFStringCreateWithPascalStringNoCopy((CFAllocatorRef)NULL,
4267 pStr,
4268 encoding,
4269 (CFAllocatorRef)NULL);
4270 _res = Py_BuildValue("O&",
4271 CFStringRefObj_New, _rv);
4272 return _res;
4273}
4274
4275static PyObject *CF_CFStringCreateWithCStringNoCopy(PyObject *_self, PyObject *_args)
4276{
4277 PyObject *_res = NULL;
4278 CFStringRef _rv;
4279 char* cStr;
4280 CFStringEncoding encoding;
4281#ifndef CFStringCreateWithCStringNoCopy
4282 PyMac_PRECHECK(CFStringCreateWithCStringNoCopy);
4283#endif
4284 if (!PyArg_ParseTuple(_args, "sl",
4285 &cStr,
4286 &encoding))
4287 return NULL;
4288 _rv = CFStringCreateWithCStringNoCopy((CFAllocatorRef)NULL,
4289 cStr,
4290 encoding,
4291 (CFAllocatorRef)NULL);
4292 _res = Py_BuildValue("O&",
4293 CFStringRefObj_New, _rv);
4294 return _res;
4295}
4296
4297static PyObject *CF_CFStringCreateWithCharactersNoCopy(PyObject *_self, PyObject *_args)
4298{
4299 PyObject *_res = NULL;
4300 CFStringRef _rv;
4301 UniChar *chars__in__;
4302 UniCharCount chars__len__;
4303 int chars__in_len__;
4304#ifndef CFStringCreateWithCharactersNoCopy
4305 PyMac_PRECHECK(CFStringCreateWithCharactersNoCopy);
4306#endif
4307 if (!PyArg_ParseTuple(_args, "u#",
4308 &chars__in__, &chars__in_len__))
4309 return NULL;
4310 chars__len__ = chars__in_len__;
4311 _rv = CFStringCreateWithCharactersNoCopy((CFAllocatorRef)NULL,
4312 chars__in__, chars__len__,
4313 (CFAllocatorRef)NULL);
4314 _res = Py_BuildValue("O&",
4315 CFStringRefObj_New, _rv);
4316 return _res;
4317}
4318
4319static PyObject *CF_CFStringCreateMutable(PyObject *_self, PyObject *_args)
4320{
4321 PyObject *_res = NULL;
4322 CFMutableStringRef _rv;
4323 CFIndex maxLength;
4324#ifndef CFStringCreateMutable
4325 PyMac_PRECHECK(CFStringCreateMutable);
4326#endif
4327 if (!PyArg_ParseTuple(_args, "l",
4328 &maxLength))
4329 return NULL;
4330 _rv = CFStringCreateMutable((CFAllocatorRef)NULL,
4331 maxLength);
4332 _res = Py_BuildValue("O&",
4333 CFMutableStringRefObj_New, _rv);
4334 return _res;
4335}
4336
4337static PyObject *CF_CFStringCreateMutableCopy(PyObject *_self, PyObject *_args)
4338{
4339 PyObject *_res = NULL;
4340 CFMutableStringRef _rv;
4341 CFIndex maxLength;
4342 CFStringRef theString;
4343#ifndef CFStringCreateMutableCopy
4344 PyMac_PRECHECK(CFStringCreateMutableCopy);
4345#endif
4346 if (!PyArg_ParseTuple(_args, "lO&",
4347 &maxLength,
4348 CFStringRefObj_Convert, &theString))
4349 return NULL;
4350 _rv = CFStringCreateMutableCopy((CFAllocatorRef)NULL,
4351 maxLength,
4352 theString);
4353 _res = Py_BuildValue("O&",
4354 CFMutableStringRefObj_New, _rv);
4355 return _res;
4356}
4357
4358static PyObject *CF_CFStringCreateWithBytes(PyObject *_self, PyObject *_args)
4359{
4360 PyObject *_res = NULL;
4361 CFStringRef _rv;
4362 unsigned char *bytes__in__;
4363 long bytes__len__;
4364 int bytes__in_len__;
4365 CFStringEncoding encoding;
4366 Boolean isExternalRepresentation;
4367#ifndef CFStringCreateWithBytes
4368 PyMac_PRECHECK(CFStringCreateWithBytes);
4369#endif
4370 if (!PyArg_ParseTuple(_args, "s#ll",
4371 &bytes__in__, &bytes__in_len__,
4372 &encoding,
4373 &isExternalRepresentation))
4374 return NULL;
4375 bytes__len__ = bytes__in_len__;
4376 _rv = CFStringCreateWithBytes((CFAllocatorRef)NULL,
4377 bytes__in__, bytes__len__,
4378 encoding,
4379 isExternalRepresentation);
4380 _res = Py_BuildValue("O&",
4381 CFStringRefObj_New, _rv);
4382 return _res;
4383}
4384
4385static PyObject *CF_CFStringGetSystemEncoding(PyObject *_self, PyObject *_args)
4386{
4387 PyObject *_res = NULL;
4388 CFStringEncoding _rv;
4389#ifndef CFStringGetSystemEncoding
4390 PyMac_PRECHECK(CFStringGetSystemEncoding);
4391#endif
4392 if (!PyArg_ParseTuple(_args, ""))
4393 return NULL;
4394 _rv = CFStringGetSystemEncoding();
4395 _res = Py_BuildValue("l",
4396 _rv);
4397 return _res;
4398}
4399
4400static PyObject *CF_CFStringGetMaximumSizeForEncoding(PyObject *_self, PyObject *_args)
4401{
4402 PyObject *_res = NULL;
4403 CFIndex _rv;
4404 CFIndex length;
4405 CFStringEncoding encoding;
4406#ifndef CFStringGetMaximumSizeForEncoding
4407 PyMac_PRECHECK(CFStringGetMaximumSizeForEncoding);
4408#endif
4409 if (!PyArg_ParseTuple(_args, "ll",
4410 &length,
4411 &encoding))
4412 return NULL;
4413 _rv = CFStringGetMaximumSizeForEncoding(length,
4414 encoding);
4415 _res = Py_BuildValue("l",
4416 _rv);
4417 return _res;
4418}
4419
4420static PyObject *CF_CFStringIsEncodingAvailable(PyObject *_self, PyObject *_args)
4421{
4422 PyObject *_res = NULL;
4423 Boolean _rv;
4424 CFStringEncoding encoding;
4425#ifndef CFStringIsEncodingAvailable
4426 PyMac_PRECHECK(CFStringIsEncodingAvailable);
4427#endif
4428 if (!PyArg_ParseTuple(_args, "l",
4429 &encoding))
4430 return NULL;
4431 _rv = CFStringIsEncodingAvailable(encoding);
4432 _res = Py_BuildValue("l",
4433 _rv);
4434 return _res;
4435}
4436
4437static PyObject *CF_CFStringGetNameOfEncoding(PyObject *_self, PyObject *_args)
4438{
4439 PyObject *_res = NULL;
4440 CFStringRef _rv;
4441 CFStringEncoding encoding;
4442#ifndef CFStringGetNameOfEncoding
4443 PyMac_PRECHECK(CFStringGetNameOfEncoding);
4444#endif
4445 if (!PyArg_ParseTuple(_args, "l",
4446 &encoding))
4447 return NULL;
4448 _rv = CFStringGetNameOfEncoding(encoding);
4449 _res = Py_BuildValue("O&",
4450 CFStringRefObj_New, _rv);
4451 return _res;
4452}
4453
4454static PyObject *CF_CFStringConvertEncodingToNSStringEncoding(PyObject *_self, PyObject *_args)
4455{
4456 PyObject *_res = NULL;
4457 UInt32 _rv;
4458 CFStringEncoding encoding;
4459#ifndef CFStringConvertEncodingToNSStringEncoding
4460 PyMac_PRECHECK(CFStringConvertEncodingToNSStringEncoding);
4461#endif
4462 if (!PyArg_ParseTuple(_args, "l",
4463 &encoding))
4464 return NULL;
4465 _rv = CFStringConvertEncodingToNSStringEncoding(encoding);
4466 _res = Py_BuildValue("l",
4467 _rv);
4468 return _res;
4469}
4470
4471static PyObject *CF_CFStringConvertNSStringEncodingToEncoding(PyObject *_self, PyObject *_args)
4472{
4473 PyObject *_res = NULL;
4474 CFStringEncoding _rv;
4475 UInt32 encoding;
4476#ifndef CFStringConvertNSStringEncodingToEncoding
4477 PyMac_PRECHECK(CFStringConvertNSStringEncodingToEncoding);
4478#endif
4479 if (!PyArg_ParseTuple(_args, "l",
4480 &encoding))
4481 return NULL;
4482 _rv = CFStringConvertNSStringEncodingToEncoding(encoding);
4483 _res = Py_BuildValue("l",
4484 _rv);
4485 return _res;
4486}
4487
4488static PyObject *CF_CFStringConvertEncodingToWindowsCodepage(PyObject *_self, PyObject *_args)
4489{
4490 PyObject *_res = NULL;
4491 UInt32 _rv;
4492 CFStringEncoding encoding;
4493#ifndef CFStringConvertEncodingToWindowsCodepage
4494 PyMac_PRECHECK(CFStringConvertEncodingToWindowsCodepage);
4495#endif
4496 if (!PyArg_ParseTuple(_args, "l",
4497 &encoding))
4498 return NULL;
4499 _rv = CFStringConvertEncodingToWindowsCodepage(encoding);
4500 _res = Py_BuildValue("l",
4501 _rv);
4502 return _res;
4503}
4504
4505static PyObject *CF_CFStringConvertWindowsCodepageToEncoding(PyObject *_self, PyObject *_args)
4506{
4507 PyObject *_res = NULL;
4508 CFStringEncoding _rv;
4509 UInt32 codepage;
4510#ifndef CFStringConvertWindowsCodepageToEncoding
4511 PyMac_PRECHECK(CFStringConvertWindowsCodepageToEncoding);
4512#endif
4513 if (!PyArg_ParseTuple(_args, "l",
4514 &codepage))
4515 return NULL;
4516 _rv = CFStringConvertWindowsCodepageToEncoding(codepage);
4517 _res = Py_BuildValue("l",
4518 _rv);
4519 return _res;
4520}
4521
4522static PyObject *CF_CFStringConvertEncodingToIANACharSetName(PyObject *_self, PyObject *_args)
4523{
4524 PyObject *_res = NULL;
4525 CFStringRef _rv;
4526 CFStringEncoding encoding;
4527#ifndef CFStringConvertEncodingToIANACharSetName
4528 PyMac_PRECHECK(CFStringConvertEncodingToIANACharSetName);
4529#endif
4530 if (!PyArg_ParseTuple(_args, "l",
4531 &encoding))
4532 return NULL;
4533 _rv = CFStringConvertEncodingToIANACharSetName(encoding);
4534 _res = Py_BuildValue("O&",
4535 CFStringRefObj_New, _rv);
4536 return _res;
4537}
4538
4539static PyObject *CF_CFStringGetMostCompatibleMacStringEncoding(PyObject *_self, PyObject *_args)
4540{
4541 PyObject *_res = NULL;
4542 CFStringEncoding _rv;
4543 CFStringEncoding encoding;
4544#ifndef CFStringGetMostCompatibleMacStringEncoding
4545 PyMac_PRECHECK(CFStringGetMostCompatibleMacStringEncoding);
4546#endif
4547 if (!PyArg_ParseTuple(_args, "l",
4548 &encoding))
4549 return NULL;
4550 _rv = CFStringGetMostCompatibleMacStringEncoding(encoding);
4551 _res = Py_BuildValue("l",
4552 _rv);
4553 return _res;
4554}
4555
4556static PyObject *CF___CFStringMakeConstantString(PyObject *_self, PyObject *_args)
4557{
4558 PyObject *_res = NULL;
4559 CFStringRef _rv;
4560 char* cStr;
4561#ifndef __CFStringMakeConstantString
4562 PyMac_PRECHECK(__CFStringMakeConstantString);
4563#endif
4564 if (!PyArg_ParseTuple(_args, "s",
4565 &cStr))
4566 return NULL;
4567 _rv = __CFStringMakeConstantString(cStr);
4568 _res = Py_BuildValue("O&",
4569 CFStringRefObj_New, _rv);
4570 return _res;
4571}
4572
4573static PyObject *CF_CFURLGetTypeID(PyObject *_self, PyObject *_args)
4574{
4575 PyObject *_res = NULL;
4576 CFTypeID _rv;
4577#ifndef CFURLGetTypeID
4578 PyMac_PRECHECK(CFURLGetTypeID);
4579#endif
4580 if (!PyArg_ParseTuple(_args, ""))
4581 return NULL;
4582 _rv = CFURLGetTypeID();
4583 _res = Py_BuildValue("l",
4584 _rv);
4585 return _res;
4586}
4587
4588static PyObject *CF_CFURLCreateWithBytes(PyObject *_self, PyObject *_args)
4589{
4590 PyObject *_res = NULL;
4591 CFURLRef _rv;
4592 unsigned char *URLBytes__in__;
4593 long URLBytes__len__;
4594 int URLBytes__in_len__;
4595 CFStringEncoding encoding;
4596 CFURLRef baseURL;
4597#ifndef CFURLCreateWithBytes
4598 PyMac_PRECHECK(CFURLCreateWithBytes);
4599#endif
4600 if (!PyArg_ParseTuple(_args, "s#lO&",
4601 &URLBytes__in__, &URLBytes__in_len__,
4602 &encoding,
4603 OptionalCFURLRefObj_Convert, &baseURL))
4604 return NULL;
4605 URLBytes__len__ = URLBytes__in_len__;
4606 _rv = CFURLCreateWithBytes((CFAllocatorRef)NULL,
4607 URLBytes__in__, URLBytes__len__,
4608 encoding,
4609 baseURL);
4610 _res = Py_BuildValue("O&",
4611 CFURLRefObj_New, _rv);
4612 return _res;
4613}
4614
4615static PyObject *CF_CFURLCreateFromFileSystemRepresentation(PyObject *_self, PyObject *_args)
4616{
4617 PyObject *_res = NULL;
4618 CFURLRef _rv;
4619 unsigned char *buffer__in__;
4620 long buffer__len__;
4621 int buffer__in_len__;
4622 Boolean isDirectory;
4623#ifndef CFURLCreateFromFileSystemRepresentation
4624 PyMac_PRECHECK(CFURLCreateFromFileSystemRepresentation);
4625#endif
4626 if (!PyArg_ParseTuple(_args, "s#l",
4627 &buffer__in__, &buffer__in_len__,
4628 &isDirectory))
4629 return NULL;
4630 buffer__len__ = buffer__in_len__;
4631 _rv = CFURLCreateFromFileSystemRepresentation((CFAllocatorRef)NULL,
4632 buffer__in__, buffer__len__,
4633 isDirectory);
4634 _res = Py_BuildValue("O&",
4635 CFURLRefObj_New, _rv);
4636 return _res;
4637}
4638
4639static PyObject *CF_CFURLCreateFromFileSystemRepresentationRelativeToBase(PyObject *_self, PyObject *_args)
4640{
4641 PyObject *_res = NULL;
4642 CFURLRef _rv;
4643 unsigned char *buffer__in__;
4644 long buffer__len__;
4645 int buffer__in_len__;
4646 Boolean isDirectory;
4647 CFURLRef baseURL;
4648#ifndef CFURLCreateFromFileSystemRepresentationRelativeToBase
4649 PyMac_PRECHECK(CFURLCreateFromFileSystemRepresentationRelativeToBase);
4650#endif
4651 if (!PyArg_ParseTuple(_args, "s#lO&",
4652 &buffer__in__, &buffer__in_len__,
4653 &isDirectory,
4654 OptionalCFURLRefObj_Convert, &baseURL))
4655 return NULL;
4656 buffer__len__ = buffer__in_len__;
4657 _rv = CFURLCreateFromFileSystemRepresentationRelativeToBase((CFAllocatorRef)NULL,
4658 buffer__in__, buffer__len__,
4659 isDirectory,
4660 baseURL);
4661 _res = Py_BuildValue("O&",
4662 CFURLRefObj_New, _rv);
4663 return _res;
4664}
4665
4666static PyObject *CF_CFURLCreateFromFSRef(PyObject *_self, PyObject *_args)
4667{
4668 PyObject *_res = NULL;
4669 CFURLRef _rv;
4670 FSRef fsRef;
4671#ifndef CFURLCreateFromFSRef
4672 PyMac_PRECHECK(CFURLCreateFromFSRef);
4673#endif
4674 if (!PyArg_ParseTuple(_args, "O&",
4675 PyMac_GetFSRef, &fsRef))
4676 return NULL;
4677 _rv = CFURLCreateFromFSRef((CFAllocatorRef)NULL,
4678 &fsRef);
4679 _res = Py_BuildValue("O&",
4680 CFURLRefObj_New, _rv);
4681 return _res;
4682}
4683
4684static PyObject *CF_toCF(PyObject *_self, PyObject *_args)
4685{
4686 PyObject *_res = NULL;
4687
4688 CFTypeRef rv;
4689 CFTypeID typeid;
4690
4691 if (!PyArg_ParseTuple(_args, "O&", PyCF_Python2CF, &rv))
4692 return NULL;
4693 typeid = CFGetTypeID(rv);
4694
4695 if (typeid == CFStringGetTypeID())
4696 return Py_BuildValue("O&", CFStringRefObj_New, rv);
4697 if (typeid == CFArrayGetTypeID())
4698 return Py_BuildValue("O&", CFArrayRefObj_New, rv);
4699 if (typeid == CFDictionaryGetTypeID())
4700 return Py_BuildValue("O&", CFDictionaryRefObj_New, rv);
4701 if (typeid == CFURLGetTypeID())
4702 return Py_BuildValue("O&", CFURLRefObj_New, rv);
4703
4704 _res = Py_BuildValue("O&", CFTypeRefObj_New, rv);
4705 return _res;
4706
4707}
4708
4709static PyMethodDef CF_methods[] = {
4710 {"__CFRangeMake", (PyCFunction)CF___CFRangeMake, 1,
4711 PyDoc_STR("(CFIndex loc, CFIndex len) -> (CFRange _rv)")},
4712 {"CFAllocatorGetTypeID", (PyCFunction)CF_CFAllocatorGetTypeID, 1,
4713 PyDoc_STR("() -> (CFTypeID _rv)")},
4714 {"CFAllocatorGetPreferredSizeForSize", (PyCFunction)CF_CFAllocatorGetPreferredSizeForSize, 1,
4715 PyDoc_STR("(CFIndex size, CFOptionFlags hint) -> (CFIndex _rv)")},
4716 {"CFCopyTypeIDDescription", (PyCFunction)CF_CFCopyTypeIDDescription, 1,
4717 PyDoc_STR("(CFTypeID type_id) -> (CFStringRef _rv)")},
4718 {"CFArrayGetTypeID", (PyCFunction)CF_CFArrayGetTypeID, 1,
4719 PyDoc_STR("() -> (CFTypeID _rv)")},
4720 {"CFArrayCreateMutable", (PyCFunction)CF_CFArrayCreateMutable, 1,
4721 PyDoc_STR("(CFIndex capacity) -> (CFMutableArrayRef _rv)")},
4722 {"CFArrayCreateMutableCopy", (PyCFunction)CF_CFArrayCreateMutableCopy, 1,
4723 PyDoc_STR("(CFIndex capacity, CFArrayRef theArray) -> (CFMutableArrayRef _rv)")},
4724 {"CFDataGetTypeID", (PyCFunction)CF_CFDataGetTypeID, 1,
4725 PyDoc_STR("() -> (CFTypeID _rv)")},
4726 {"CFDataCreate", (PyCFunction)CF_CFDataCreate, 1,
4727 PyDoc_STR("(Buffer bytes) -> (CFDataRef _rv)")},
4728 {"CFDataCreateWithBytesNoCopy", (PyCFunction)CF_CFDataCreateWithBytesNoCopy, 1,
4729 PyDoc_STR("(Buffer bytes) -> (CFDataRef _rv)")},
4730 {"CFDataCreateMutable", (PyCFunction)CF_CFDataCreateMutable, 1,
4731 PyDoc_STR("(CFIndex capacity) -> (CFMutableDataRef _rv)")},
4732 {"CFDataCreateMutableCopy", (PyCFunction)CF_CFDataCreateMutableCopy, 1,
4733 PyDoc_STR("(CFIndex capacity, CFDataRef theData) -> (CFMutableDataRef _rv)")},
4734 {"CFDictionaryGetTypeID", (PyCFunction)CF_CFDictionaryGetTypeID, 1,
4735 PyDoc_STR("() -> (CFTypeID _rv)")},
4736 {"CFDictionaryCreateMutable", (PyCFunction)CF_CFDictionaryCreateMutable, 1,
4737 PyDoc_STR("(CFIndex capacity) -> (CFMutableDictionaryRef _rv)")},
4738 {"CFDictionaryCreateMutableCopy", (PyCFunction)CF_CFDictionaryCreateMutableCopy, 1,
4739 PyDoc_STR("(CFIndex capacity, CFDictionaryRef theDict) -> (CFMutableDictionaryRef _rv)")},
4740 {"CFPreferencesCopyAppValue", (PyCFunction)CF_CFPreferencesCopyAppValue, 1,
4741 PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (CFTypeRef _rv)")},
4742 {"CFPreferencesGetAppBooleanValue", (PyCFunction)CF_CFPreferencesGetAppBooleanValue, 1,
4743 PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (Boolean _rv, Boolean keyExistsAndHasValidFormat)")},
4744 {"CFPreferencesGetAppIntegerValue", (PyCFunction)CF_CFPreferencesGetAppIntegerValue, 1,
4745 PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (CFIndex _rv, Boolean keyExistsAndHasValidFormat)")},
4746 {"CFPreferencesSetAppValue", (PyCFunction)CF_CFPreferencesSetAppValue, 1,
4747 PyDoc_STR("(CFStringRef key, CFTypeRef value, CFStringRef applicationID) -> None")},
4748 {"CFPreferencesAddSuitePreferencesToApp", (PyCFunction)CF_CFPreferencesAddSuitePreferencesToApp, 1,
4749 PyDoc_STR("(CFStringRef applicationID, CFStringRef suiteID) -> None")},
4750 {"CFPreferencesRemoveSuitePreferencesFromApp", (PyCFunction)CF_CFPreferencesRemoveSuitePreferencesFromApp, 1,
4751 PyDoc_STR("(CFStringRef applicationID, CFStringRef suiteID) -> None")},
4752 {"CFPreferencesAppSynchronize", (PyCFunction)CF_CFPreferencesAppSynchronize, 1,
4753 PyDoc_STR("(CFStringRef applicationID) -> (Boolean _rv)")},
4754 {"CFPreferencesCopyValue", (PyCFunction)CF_CFPreferencesCopyValue, 1,
4755 PyDoc_STR("(CFStringRef key, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFTypeRef _rv)")},
4756 {"CFPreferencesCopyMultiple", (PyCFunction)CF_CFPreferencesCopyMultiple, 1,
4757 PyDoc_STR("(CFArrayRef keysToFetch, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFDictionaryRef _rv)")},
4758 {"CFPreferencesSetValue", (PyCFunction)CF_CFPreferencesSetValue, 1,
4759 PyDoc_STR("(CFStringRef key, CFTypeRef value, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None")},
4760 {"CFPreferencesSetMultiple", (PyCFunction)CF_CFPreferencesSetMultiple, 1,
4761 PyDoc_STR("(CFDictionaryRef keysToSet, CFArrayRef keysToRemove, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None")},
4762 {"CFPreferencesSynchronize", (PyCFunction)CF_CFPreferencesSynchronize, 1,
4763 PyDoc_STR("(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (Boolean _rv)")},
4764 {"CFPreferencesCopyApplicationList", (PyCFunction)CF_CFPreferencesCopyApplicationList, 1,
4765 PyDoc_STR("(CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)")},
4766 {"CFPreferencesCopyKeyList", (PyCFunction)CF_CFPreferencesCopyKeyList, 1,
4767 PyDoc_STR("(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)")},
4768 {"CFStringGetTypeID", (PyCFunction)CF_CFStringGetTypeID, 1,
4769 PyDoc_STR("() -> (CFTypeID _rv)")},
4770 {"CFStringCreateWithPascalString", (PyCFunction)CF_CFStringCreateWithPascalString, 1,
4771 PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)")},
4772 {"CFStringCreateWithCString", (PyCFunction)CF_CFStringCreateWithCString, 1,
4773 PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)")},
4774 {"CFStringCreateWithCharacters", (PyCFunction)CF_CFStringCreateWithCharacters, 1,
4775 PyDoc_STR("(Buffer chars) -> (CFStringRef _rv)")},
4776 {"CFStringCreateWithPascalStringNoCopy", (PyCFunction)CF_CFStringCreateWithPascalStringNoCopy, 1,
4777 PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)")},
4778 {"CFStringCreateWithCStringNoCopy", (PyCFunction)CF_CFStringCreateWithCStringNoCopy, 1,
4779 PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)")},
4780 {"CFStringCreateWithCharactersNoCopy", (PyCFunction)CF_CFStringCreateWithCharactersNoCopy, 1,
4781 PyDoc_STR("(Buffer chars) -> (CFStringRef _rv)")},
4782 {"CFStringCreateMutable", (PyCFunction)CF_CFStringCreateMutable, 1,
4783 PyDoc_STR("(CFIndex maxLength) -> (CFMutableStringRef _rv)")},
4784 {"CFStringCreateMutableCopy", (PyCFunction)CF_CFStringCreateMutableCopy, 1,
4785 PyDoc_STR("(CFIndex maxLength, CFStringRef theString) -> (CFMutableStringRef _rv)")},
4786 {"CFStringCreateWithBytes", (PyCFunction)CF_CFStringCreateWithBytes, 1,
4787 PyDoc_STR("(Buffer bytes, CFStringEncoding encoding, Boolean isExternalRepresentation) -> (CFStringRef _rv)")},
4788 {"CFStringGetSystemEncoding", (PyCFunction)CF_CFStringGetSystemEncoding, 1,
4789 PyDoc_STR("() -> (CFStringEncoding _rv)")},
4790 {"CFStringGetMaximumSizeForEncoding", (PyCFunction)CF_CFStringGetMaximumSizeForEncoding, 1,
4791 PyDoc_STR("(CFIndex length, CFStringEncoding encoding) -> (CFIndex _rv)")},
4792 {"CFStringIsEncodingAvailable", (PyCFunction)CF_CFStringIsEncodingAvailable, 1,
4793 PyDoc_STR("(CFStringEncoding encoding) -> (Boolean _rv)")},
4794 {"CFStringGetNameOfEncoding", (PyCFunction)CF_CFStringGetNameOfEncoding, 1,
4795 PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")},
4796 {"CFStringConvertEncodingToNSStringEncoding", (PyCFunction)CF_CFStringConvertEncodingToNSStringEncoding, 1,
4797 PyDoc_STR("(CFStringEncoding encoding) -> (UInt32 _rv)")},
4798 {"CFStringConvertNSStringEncodingToEncoding", (PyCFunction)CF_CFStringConvertNSStringEncodingToEncoding, 1,
4799 PyDoc_STR("(UInt32 encoding) -> (CFStringEncoding _rv)")},
4800 {"CFStringConvertEncodingToWindowsCodepage", (PyCFunction)CF_CFStringConvertEncodingToWindowsCodepage, 1,
4801 PyDoc_STR("(CFStringEncoding encoding) -> (UInt32 _rv)")},
4802 {"CFStringConvertWindowsCodepageToEncoding", (PyCFunction)CF_CFStringConvertWindowsCodepageToEncoding, 1,
4803 PyDoc_STR("(UInt32 codepage) -> (CFStringEncoding _rv)")},
4804 {"CFStringConvertEncodingToIANACharSetName", (PyCFunction)CF_CFStringConvertEncodingToIANACharSetName, 1,
4805 PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")},
4806 {"CFStringGetMostCompatibleMacStringEncoding", (PyCFunction)CF_CFStringGetMostCompatibleMacStringEncoding, 1,
4807 PyDoc_STR("(CFStringEncoding encoding) -> (CFStringEncoding _rv)")},
4808 {"__CFStringMakeConstantString", (PyCFunction)CF___CFStringMakeConstantString, 1,
4809 PyDoc_STR("(char* cStr) -> (CFStringRef _rv)")},
4810 {"CFURLGetTypeID", (PyCFunction)CF_CFURLGetTypeID, 1,
4811 PyDoc_STR("() -> (CFTypeID _rv)")},
4812 {"CFURLCreateWithBytes", (PyCFunction)CF_CFURLCreateWithBytes, 1,
4813 PyDoc_STR("(Buffer URLBytes, CFStringEncoding encoding, CFURLRef baseURL) -> (CFURLRef _rv)")},
4814 {"CFURLCreateFromFileSystemRepresentation", (PyCFunction)CF_CFURLCreateFromFileSystemRepresentation, 1,
4815 PyDoc_STR("(Buffer buffer, Boolean isDirectory) -> (CFURLRef _rv)")},
4816 {"CFURLCreateFromFileSystemRepresentationRelativeToBase", (PyCFunction)CF_CFURLCreateFromFileSystemRepresentationRelativeToBase, 1,
4817 PyDoc_STR("(Buffer buffer, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)")},
4818 {"CFURLCreateFromFSRef", (PyCFunction)CF_CFURLCreateFromFSRef, 1,
4819 PyDoc_STR("(FSRef fsRef) -> (CFURLRef _rv)")},
4820 {"toCF", (PyCFunction)CF_toCF, 1,
4821 PyDoc_STR("(python_object) -> (CF_object)")},
4822 {NULL, NULL, 0}
4823};
4824
4825
4826
4827
4828/* Routines to convert any CF type to/from the corresponding CFxxxObj */
4829PyObject *CFObj_New(CFTypeRef itself)
4830{
4831 if (itself == NULL)
4832 {
4833 PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL");
4834 return NULL;
4835 }
4836 if (CFGetTypeID(itself) == CFArrayGetTypeID()) return CFArrayRefObj_New((CFArrayRef)itself);
4837 if (CFGetTypeID(itself) == CFDictionaryGetTypeID()) return CFDictionaryRefObj_New((CFDictionaryRef)itself);
4838 if (CFGetTypeID(itself) == CFDataGetTypeID()) return CFDataRefObj_New((CFDataRef)itself);
4839 if (CFGetTypeID(itself) == CFStringGetTypeID()) return CFStringRefObj_New((CFStringRef)itself);
4840 if (CFGetTypeID(itself) == CFURLGetTypeID()) return CFURLRefObj_New((CFURLRef)itself);
4841 /* XXXX Or should we use PyCF_CF2Python here?? */
4842 return CFTypeRefObj_New(itself);
4843}
4844int CFObj_Convert(PyObject *v, CFTypeRef *p_itself)
4845{
4846
4847 if (v == Py_None) { *p_itself = NULL; return 1; }
4848 /* Check for other CF objects here */
4849
4850 if (!CFTypeRefObj_Check(v) &&
4851 !CFArrayRefObj_Check(v) &&
4852 !CFMutableArrayRefObj_Check(v) &&
4853 !CFDictionaryRefObj_Check(v) &&
4854 !CFMutableDictionaryRefObj_Check(v) &&
4855 !CFDataRefObj_Check(v) &&
4856 !CFMutableDataRefObj_Check(v) &&
4857 !CFStringRefObj_Check(v) &&
4858 !CFMutableStringRefObj_Check(v) &&
4859 !CFURLRefObj_Check(v) )
4860 {
4861 /* XXXX Or should we use PyCF_Python2CF here?? */
4862 PyErr_SetString(PyExc_TypeError, "CF object required");
4863 return 0;
4864 }
4865 *p_itself = ((CFTypeRefObject *)v)->ob_itself;
4866 return 1;
4867}
4868
4869
4870void init_CF(void)
4871{
4872 PyObject *m;
4873 PyObject *d;
4874
4875
4876
4877 PyMac_INIT_TOOLBOX_OBJECT_NEW(CFTypeRef, CFObj_New);
4878 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFTypeRef, CFObj_Convert);
4879 PyMac_INIT_TOOLBOX_OBJECT_NEW(CFTypeRef, CFTypeRefObj_New);
4880 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFTypeRef, CFTypeRefObj_Convert);
4881 PyMac_INIT_TOOLBOX_OBJECT_NEW(CFStringRef, CFStringRefObj_New);
4882 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFStringRef, CFStringRefObj_Convert);
4883 PyMac_INIT_TOOLBOX_OBJECT_NEW(CFMutableStringRef, CFMutableStringRefObj_New);
4884 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFMutableStringRef, CFMutableStringRefObj_Convert);
4885 PyMac_INIT_TOOLBOX_OBJECT_NEW(CFArrayRef, CFArrayRefObj_New);
4886 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFArrayRef, CFArrayRefObj_Convert);
4887 PyMac_INIT_TOOLBOX_OBJECT_NEW(CFMutableArrayRef, CFMutableArrayRefObj_New);
4888 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFMutableArrayRef, CFMutableArrayRefObj_Convert);
4889 PyMac_INIT_TOOLBOX_OBJECT_NEW(CFDictionaryRef, CFDictionaryRefObj_New);
4890 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFDictionaryRef, CFDictionaryRefObj_Convert);
4891 PyMac_INIT_TOOLBOX_OBJECT_NEW(CFMutableDictionaryRef, CFMutableDictionaryRefObj_New);
4892 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFMutableDictionaryRef, CFMutableDictionaryRefObj_Convert);
4893 PyMac_INIT_TOOLBOX_OBJECT_NEW(CFURLRef, CFURLRefObj_New);
4894 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFURLRef, CFURLRefObj_Convert);
4895
4896
4897 m = Py_InitModule("_CF", CF_methods);
4898 d = PyModule_GetDict(m);
4899 CF_Error = PyMac_GetOSErrException();
4900 if (CF_Error == NULL ||
4901 PyDict_SetItemString(d, "Error", CF_Error) != 0)
4902 return;
4903 CFTypeRef_Type.ob_type = &PyType_Type;
4904 if (PyType_Ready(&CFTypeRef_Type) < 0) return;
4905 Py_INCREF(&CFTypeRef_Type);
4906 PyModule_AddObject(m, "CFTypeRef", (PyObject *)&CFTypeRef_Type);
4907 /* Backward-compatible name */
4908 Py_INCREF(&CFTypeRef_Type);
4909 PyModule_AddObject(m, "CFTypeRefType", (PyObject *)&CFTypeRef_Type);
4910 CFArrayRef_Type.ob_type = &PyType_Type;
4911 CFArrayRef_Type.tp_base = &CFTypeRef_Type;
4912 if (PyType_Ready(&CFArrayRef_Type) < 0) return;
4913 Py_INCREF(&CFArrayRef_Type);
4914 PyModule_AddObject(m, "CFArrayRef", (PyObject *)&CFArrayRef_Type);
4915 /* Backward-compatible name */
4916 Py_INCREF(&CFArrayRef_Type);
4917 PyModule_AddObject(m, "CFArrayRefType", (PyObject *)&CFArrayRef_Type);
4918 CFMutableArrayRef_Type.ob_type = &PyType_Type;
4919 CFMutableArrayRef_Type.tp_base = &CFArrayRef_Type;
4920 if (PyType_Ready(&CFMutableArrayRef_Type) < 0) return;
4921 Py_INCREF(&CFMutableArrayRef_Type);
4922 PyModule_AddObject(m, "CFMutableArrayRef", (PyObject *)&CFMutableArrayRef_Type);
4923 /* Backward-compatible name */
4924 Py_INCREF(&CFMutableArrayRef_Type);
4925 PyModule_AddObject(m, "CFMutableArrayRefType", (PyObject *)&CFMutableArrayRef_Type);
4926 CFDictionaryRef_Type.ob_type = &PyType_Type;
4927 CFDictionaryRef_Type.tp_base = &CFTypeRef_Type;
4928 if (PyType_Ready(&CFDictionaryRef_Type) < 0) return;
4929 Py_INCREF(&CFDictionaryRef_Type);
4930 PyModule_AddObject(m, "CFDictionaryRef", (PyObject *)&CFDictionaryRef_Type);
4931 /* Backward-compatible name */
4932 Py_INCREF(&CFDictionaryRef_Type);
4933 PyModule_AddObject(m, "CFDictionaryRefType", (PyObject *)&CFDictionaryRef_Type);
4934 CFMutableDictionaryRef_Type.ob_type = &PyType_Type;
4935 CFMutableDictionaryRef_Type.tp_base = &CFDictionaryRef_Type;
4936 if (PyType_Ready(&CFMutableDictionaryRef_Type) < 0) return;
4937 Py_INCREF(&CFMutableDictionaryRef_Type);
4938 PyModule_AddObject(m, "CFMutableDictionaryRef", (PyObject *)&CFMutableDictionaryRef_Type);
4939 /* Backward-compatible name */
4940 Py_INCREF(&CFMutableDictionaryRef_Type);
4941 PyModule_AddObject(m, "CFMutableDictionaryRefType", (PyObject *)&CFMutableDictionaryRef_Type);
4942 CFDataRef_Type.ob_type = &PyType_Type;
4943 CFDataRef_Type.tp_base = &CFTypeRef_Type;
4944 if (PyType_Ready(&CFDataRef_Type) < 0) return;
4945 Py_INCREF(&CFDataRef_Type);
4946 PyModule_AddObject(m, "CFDataRef", (PyObject *)&CFDataRef_Type);
4947 /* Backward-compatible name */
4948 Py_INCREF(&CFDataRef_Type);
4949 PyModule_AddObject(m, "CFDataRefType", (PyObject *)&CFDataRef_Type);
4950 CFMutableDataRef_Type.ob_type = &PyType_Type;
4951 CFMutableDataRef_Type.tp_base = &CFDataRef_Type;
4952 if (PyType_Ready(&CFMutableDataRef_Type) < 0) return;
4953 Py_INCREF(&CFMutableDataRef_Type);
4954 PyModule_AddObject(m, "CFMutableDataRef", (PyObject *)&CFMutableDataRef_Type);
4955 /* Backward-compatible name */
4956 Py_INCREF(&CFMutableDataRef_Type);
4957 PyModule_AddObject(m, "CFMutableDataRefType", (PyObject *)&CFMutableDataRef_Type);
4958 CFStringRef_Type.ob_type = &PyType_Type;
4959 CFStringRef_Type.tp_base = &CFTypeRef_Type;
4960 if (PyType_Ready(&CFStringRef_Type) < 0) return;
4961 Py_INCREF(&CFStringRef_Type);
4962 PyModule_AddObject(m, "CFStringRef", (PyObject *)&CFStringRef_Type);
4963 /* Backward-compatible name */
4964 Py_INCREF(&CFStringRef_Type);
4965 PyModule_AddObject(m, "CFStringRefType", (PyObject *)&CFStringRef_Type);
4966 CFMutableStringRef_Type.ob_type = &PyType_Type;
4967 CFMutableStringRef_Type.tp_base = &CFStringRef_Type;
4968 if (PyType_Ready(&CFMutableStringRef_Type) < 0) return;
4969 Py_INCREF(&CFMutableStringRef_Type);
4970 PyModule_AddObject(m, "CFMutableStringRef", (PyObject *)&CFMutableStringRef_Type);
4971 /* Backward-compatible name */
4972 Py_INCREF(&CFMutableStringRef_Type);
4973 PyModule_AddObject(m, "CFMutableStringRefType", (PyObject *)&CFMutableStringRef_Type);
4974 CFURLRef_Type.ob_type = &PyType_Type;
4975 CFURLRef_Type.tp_base = &CFTypeRef_Type;
4976 if (PyType_Ready(&CFURLRef_Type) < 0) return;
4977 Py_INCREF(&CFURLRef_Type);
4978 PyModule_AddObject(m, "CFURLRef", (PyObject *)&CFURLRef_Type);
4979 /* Backward-compatible name */
4980 Py_INCREF(&CFURLRef_Type);
4981 PyModule_AddObject(m, "CFURLRefType", (PyObject *)&CFURLRef_Type);
4982
4983#define _STRINGCONST(name) PyModule_AddObject(m, #name, CFStringRefObj_New(name))
4984 _STRINGCONST(kCFPreferencesAnyApplication);
4985 _STRINGCONST(kCFPreferencesCurrentApplication);
4986 _STRINGCONST(kCFPreferencesAnyHost);
4987 _STRINGCONST(kCFPreferencesCurrentHost);
4988 _STRINGCONST(kCFPreferencesAnyUser);
4989 _STRINGCONST(kCFPreferencesCurrentUser);
4990
4991
4992
4993}
4994
4995/* ========================= End module _CF ========================= */
4996
Note: See TracBrowser for help on using the repository browser.