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