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 */ 84 PyObject *CFRange_New(CFRange *itself) 85 { 86 return Py_BuildValue("ll", (long)itself->location, (long)itself->length); 87 } 88 89 int 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 397 static int CFTypeRefObj_hash(CFTypeRefObject *self) 398 { 399 /* XXXX Or should we use CFHash?? */ 400 return (int)self->ob_itself; 401 } 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 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 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 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 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 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 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 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 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 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 601 static int CFArrayRefObj_hash(CFArrayRefObject *self) 602 { 603 /* XXXX Or should we use CFHash?? */ 604 return (int)self->ob_itself; 605 } 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 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 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 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 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 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 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 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 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 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 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 841 static int CFMutableArrayRefObj_hash(CFMutableArrayRefObject *self) 842 { 843 /* XXXX Or should we use CFHash?? */ 844 return (int)self->ob_itself; 845 } 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 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 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 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 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 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 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 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 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 1034 static int CFDictionaryRefObj_hash(CFDictionaryRefObject *self) 1035 { 1036 /* XXXX Or should we use CFHash?? */ 1037 return (int)self->ob_itself; 1038 } 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 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 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 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 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 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 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 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 1211 static int CFMutableDictionaryRefObj_hash(CFMutableDictionaryRefObject *self) 1212 { 1213 /* XXXX Or should we use CFHash?? */ 1214 return (int)self->ob_itself; 1215 } 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 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 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 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 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 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 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 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 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 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 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 1442 static int CFDataRefObj_hash(CFDataRefObject *self) 1443 { 1444 /* XXXX Or should we use CFHash?? */ 1445 return (int)self->ob_itself; 1446 } 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 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 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 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 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 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 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 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 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 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 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 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 1707 static int CFMutableDataRefObj_hash(CFMutableDataRefObject *self) 1708 { 1709 /* XXXX Or should we use CFHash?? */ 1710 return (int)self->ob_itself; 1711 } 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 2450 static int CFStringRefObj_hash(CFStringRefObject *self) 2451 { 2452 /* XXXX Or should we use CFHash?? */ 2453 return (int)self->ob_itself; 2454 } 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 2838 static int CFMutableStringRefObj_hash(CFMutableStringRefObject *self) 2839 { 2840 /* XXXX Or should we use CFHash?? */ 2841 return (int)self->ob_itself; 2842 } 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 3490 static int CFURLRefObj_hash(CFURLRefObject *self) 3491 { 3492 /* XXXX Or should we use CFHash?? */ 3493 return (int)self->ob_itself; 3494 } 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 */ 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 } 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 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
