1 2/* =========================== Module _CF =========================== */ 3 4#include "Python.h" 5 6 7 8#include "pymactoolbox.h" 9 10/* Macro to test whether a weak-loaded CFM function exists */ 11#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\ 12 PyErr_SetString(PyExc_NotImplementedError, \ 13 "Not available in this shared library/OS version"); \ 14 return NULL; \ 15 }} while(0) 16 17 18#include <CoreServices/CoreServices.h> 19 20#include "pycfbridge.h" 21 22#ifdef USE_TOOLBOX_OBJECT_GLUE 23extern PyObject *_CFObj_New(CFTypeRef); 24extern int _CFObj_Convert(PyObject *, CFTypeRef *); 25#define CFObj_New _CFObj_New 26#define CFObj_Convert _CFObj_Convert 27 28extern PyObject *_CFTypeRefObj_New(CFTypeRef); 29extern int _CFTypeRefObj_Convert(PyObject *, CFTypeRef *); 30#define CFTypeRefObj_New _CFTypeRefObj_New 31#define CFTypeRefObj_Convert _CFTypeRefObj_Convert 32 33extern PyObject *_CFStringRefObj_New(CFStringRef); 34extern int _CFStringRefObj_Convert(PyObject *, CFStringRef *); 35#define CFStringRefObj_New _CFStringRefObj_New 36#define CFStringRefObj_Convert _CFStringRefObj_Convert 37 38extern PyObject *_CFMutableStringRefObj_New(CFMutableStringRef); 39extern int _CFMutableStringRefObj_Convert(PyObject *, CFMutableStringRef *); 40#define CFMutableStringRefObj_New _CFMutableStringRefObj_New 41#define CFMutableStringRefObj_Convert _CFMutableStringRefObj_Convert 42 43extern PyObject *_CFArrayRefObj_New(CFArrayRef); 44extern int _CFArrayRefObj_Convert(PyObject *, CFArrayRef *); 45#define CFArrayRefObj_New _CFArrayRefObj_New 46#define CFArrayRefObj_Convert _CFArrayRefObj_Convert 47 48extern PyObject *_CFMutableArrayRefObj_New(CFMutableArrayRef); 49extern int _CFMutableArrayRefObj_Convert(PyObject *, CFMutableArrayRef *); 50#define CFMutableArrayRefObj_New _CFMutableArrayRefObj_New 51#define CFMutableArrayRefObj_Convert _CFMutableArrayRefObj_Convert 52 53extern PyObject *_CFDataRefObj_New(CFDataRef); 54extern int _CFDataRefObj_Convert(PyObject *, CFDataRef *); 55#define CFDataRefObj_New _CFDataRefObj_New 56#define CFDataRefObj_Convert _CFDataRefObj_Convert 57 58extern PyObject *_CFMutableDataRefObj_New(CFMutableDataRef); 59extern int _CFMutableDataRefObj_Convert(PyObject *, CFMutableDataRef *); 60#define CFMutableDataRefObj_New _CFMutableDataRefObj_New 61#define CFMutableDataRefObj_Convert _CFMutableDataRefObj_Convert 62 63extern PyObject *_CFDictionaryRefObj_New(CFDictionaryRef); 64extern int _CFDictionaryRefObj_Convert(PyObject *, CFDictionaryRef *); 65#define CFDictionaryRefObj_New _CFDictionaryRefObj_New 66#define CFDictionaryRefObj_Convert _CFDictionaryRefObj_Convert 67 68extern PyObject *_CFMutableDictionaryRefObj_New(CFMutableDictionaryRef); 69extern int _CFMutableDictionaryRefObj_Convert(PyObject *, CFMutableDictionaryRef *); 70#define CFMutableDictionaryRefObj_New _CFMutableDictionaryRefObj_New 71#define CFMutableDictionaryRefObj_Convert _CFMutableDictionaryRefObj_Convert 72 73extern PyObject *_CFURLRefObj_New(CFURLRef); 74extern int _CFURLRefObj_Convert(PyObject *, CFURLRef *); 75extern int _OptionalCFURLRefObj_Convert(PyObject *, CFURLRef *); 76#define CFURLRefObj_New _CFURLRefObj_New 77#define CFURLRefObj_Convert _CFURLRefObj_Convert 78#define OptionalCFURLRefObj_Convert _OptionalCFURLRefObj_Convert 79#endif 80 81/* 82** Parse/generate CFRange records 83*/ 84PyObject *CFRange_New(CFRange *itself) 85{ 86 return Py_BuildValue("ll", (long)itself->location, (long)itself->length); 87} 88 89int 90CFRange_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) */ 102int 103OptionalCFURLRefObj_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 112static PyObject *CF_Error; 113 114/* --------------------- Object type CFTypeRef ---------------------- */ 115 116PyTypeObject CFTypeRef_Type; 117 118#define CFTypeRefObj_Check(x) ((x)->ob_type == &CFTypeRef_Type || PyObject_TypeCheck((x), &CFTypeRef_Type)) 119 120typedef struct CFTypeRefObject { 121 PyObject_HEAD 122 CFTypeRef ob_itself; 123 void (*ob_freeit)(CFTypeRef ptr); 124} CFTypeRefObject; 125 126PyObject *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 141int 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 156static 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 166static 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 181static 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 196static 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 210static 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 225static 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 243static 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 258static 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 273static 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 286static 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 302static 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 316static 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 342static 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 351static 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 382static 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 390static 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 397static int CFTypeRefObj_hash(CFTypeRefObject *self) 398{ 399 /* XXXX Or should we use CFHash?? */ 400 return (int)self->ob_itself; 401} 402static 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 417static 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 429PyTypeObject 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 478PyTypeObject CFArrayRef_Type; 479 480#define CFArrayRefObj_Check(x) ((x)->ob_type == &CFArrayRef_Type || PyObject_TypeCheck((x), &CFArrayRef_Type)) 481 482typedef struct CFArrayRefObject { 483 PyObject_HEAD 484 CFArrayRef ob_itself; 485 void (*ob_freeit)(CFTypeRef ptr); 486} CFArrayRefObject; 487 488PyObject *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 504int 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 519static 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 529static 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 542static 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 557static 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 573static 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 586static 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 594static 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 601static int CFArrayRefObj_hash(CFArrayRefObject *self) 602{ 603 /* XXXX Or should we use CFHash?? */ 604 return (int)self->ob_itself; 605} 606static 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 628static 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 640PyTypeObject 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 689PyTypeObject CFMutableArrayRef_Type; 690 691#define CFMutableArrayRefObj_Check(x) ((x)->ob_type == &CFMutableArrayRef_Type || PyObject_TypeCheck((x), &CFMutableArrayRef_Type)) 692 693typedef struct CFMutableArrayRefObject { 694 PyObject_HEAD 695 CFMutableArrayRef ob_itself; 696 void (*ob_freeit)(CFTypeRef ptr); 697} CFMutableArrayRefObject; 698 699PyObject *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 715int 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 730static 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 740static 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 757static 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 771static 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 791static 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 811static 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 826static 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 834static 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 841static int CFMutableArrayRefObj_hash(CFMutableArrayRefObject *self) 842{ 843 /* XXXX Or should we use CFHash?? */ 844 return (int)self->ob_itself; 845} 846static 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 868static 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 880PyTypeObject 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 929PyTypeObject CFDictionaryRef_Type; 930 931#define CFDictionaryRefObj_Check(x) ((x)->ob_type == &CFDictionaryRef_Type || PyObject_TypeCheck((x), &CFDictionaryRef_Type)) 932 933typedef struct CFDictionaryRefObject { 934 PyObject_HEAD 935 CFDictionaryRef ob_itself; 936 void (*ob_freeit)(CFTypeRef ptr); 937} CFDictionaryRefObject; 938 939PyObject *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 955int 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 970static 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 980static 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 993static 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 1008static 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 1019static 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 1027static 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 1034static int CFDictionaryRefObj_hash(CFDictionaryRefObject *self) 1035{ 1036 /* XXXX Or should we use CFHash?? */ 1037 return (int)self->ob_itself; 1038} 1039static 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 1061static 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 1073PyTypeObject 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 1122PyTypeObject CFMutableDictionaryRef_Type; 1123 1124#define CFMutableDictionaryRefObj_Check(x) ((x)->ob_type == &CFMutableDictionaryRef_Type || PyObject_TypeCheck((x), &CFMutableDictionaryRef_Type)) 1125 1126typedef struct CFMutableDictionaryRefObject { 1127 PyObject_HEAD 1128 CFMutableDictionaryRef ob_itself; 1129 void (*ob_freeit)(CFTypeRef ptr); 1130} CFMutableDictionaryRefObject; 1131 1132PyObject *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 1148int 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 1163static 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 1173static 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 1187static 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 1196static 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 1204static 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 1211static int CFMutableDictionaryRefObj_hash(CFMutableDictionaryRefObject *self) 1212{ 1213 /* XXXX Or should we use CFHash?? */ 1214 return (int)self->ob_itself; 1215} 1216static 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 1238static 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 1250PyTypeObject 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 1299PyTypeObject CFDataRef_Type; 1300 1301#define CFDataRefObj_Check(x) ((x)->ob_type == &CFDataRef_Type || PyObject_TypeCheck((x), &CFDataRef_Type)) 1302 1303typedef struct CFDataRefObject { 1304 PyObject_HEAD 1305 CFDataRef ob_itself; 1306 void (*ob_freeit)(CFTypeRef ptr); 1307} CFDataRefObject; 1308 1309PyObject *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 1325int 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 1346static 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 1356static 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 1369static 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 1384static 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 1400static 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 1412static 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 1427static 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 1435static 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 1442static int CFDataRefObj_hash(CFDataRefObject *self) 1443{ 1444 /* XXXX Or should we use CFHash?? */ 1445 return (int)self->ob_itself; 1446} 1447static 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 1469static 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 1481PyTypeObject 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 1530PyTypeObject CFMutableDataRef_Type; 1531 1532#define CFMutableDataRefObj_Check(x) ((x)->ob_type == &CFMutableDataRef_Type || PyObject_TypeCheck((x), &CFMutableDataRef_Type)) 1533 1534typedef struct CFMutableDataRefObject { 1535 PyObject_HEAD 1536 CFMutableDataRef ob_itself; 1537 void (*ob_freeit)(CFTypeRef ptr); 1538} CFMutableDataRefObject; 1539 1540PyObject *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 1556int 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 1571static 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 1581static 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 1598static 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 1615static 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 1635static 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 1658static 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 1675static 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 1692static 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 1700static 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 1707static int CFMutableDataRefObj_hash(CFMutableDataRefObject *self) 1708{ 1709 /* XXXX Or should we use CFHash?? */ 1710 return (int)self->ob_itself; 1711} 1712static 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 1734static 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 1746PyTypeObject 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 1795PyTypeObject CFStringRef_Type; 1796 1797#define CFStringRefObj_Check(x) ((x)->ob_type == &CFStringRef_Type || PyObject_TypeCheck((x), &CFStringRef_Type)) 1798 1799typedef struct CFStringRefObject { 1800 PyObject_HEAD 1801 CFStringRef ob_itself; 1802 void (*ob_freeit)(CFTypeRef ptr); 1803} CFStringRefObject; 1804 1805PyObject *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 1821int 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 1852static 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 1862static 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 1878static 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 1891static 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 1906static 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 1942static 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 1961static 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 1976static 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 1991static 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 2015static 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 2036static 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 2063static 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 2085static 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 2106static 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 2124static 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 2142static 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 2167static 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 2183static 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 2198static 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 2213static 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 2228static 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 2242static 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 2258static 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 2277static 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 2299static 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 2315static 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 2337static 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 2356static 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 2374static 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 2435static 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 2443static 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 2450static int CFStringRefObj_hash(CFStringRefObject *self) 2451{ 2452 /* XXXX Or should we use CFHash?? */ 2453 return (int)self->ob_itself; 2454} 2455static 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 2477static 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 2489PyTypeObject 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 2538PyTypeObject CFMutableStringRef_Type; 2539 2540#define CFMutableStringRefObj_Check(x) ((x)->ob_type == &CFMutableStringRef_Type || PyObject_TypeCheck((x), &CFMutableStringRef_Type)) 2541 2542typedef struct CFMutableStringRefObject { 2543 PyObject_HEAD 2544 CFMutableStringRef ob_itself; 2545 void (*ob_freeit)(CFTypeRef ptr); 2546} CFMutableStringRefObject; 2547 2548PyObject *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 2564int 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 2579static 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 2589static 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 2606static 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 2626static 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 2646static 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 2666static 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 2686static 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 2703static 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 2723static 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 2740static 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 2763static 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 2780static 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 2794static 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 2823static 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 2831static 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 2838static int CFMutableStringRefObj_hash(CFMutableStringRefObject *self) 2839{ 2840 /* XXXX Or should we use CFHash?? */ 2841 return (int)self->ob_itself; 2842} 2843static 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 2865static 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 2877PyTypeObject 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 2926PyTypeObject CFURLRef_Type; 2927 2928#define CFURLRefObj_Check(x) ((x)->ob_type == &CFURLRef_Type || PyObject_TypeCheck((x), &CFURLRef_Type)) 2929 2930typedef struct CFURLRefObject { 2931 PyObject_HEAD 2932 CFURLRef ob_itself; 2933 void (*ob_freeit)(CFTypeRef ptr); 2934} CFURLRefObject; 2935 2936PyObject *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 2952int 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 2967static 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 2977static 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 2996static 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 3020static 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 3035static 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 3050static 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 3065static 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 3080static 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 3095static 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 3110static 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 3125static 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 3143static 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 3161static 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 3176static 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 3191static 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 3206static 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 3221static 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 3236static 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 3251static 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 3269static 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 3287static 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 3305static 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 3320static 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 3335static 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 3354static 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 3367static 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 3383static 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 3396static 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 3414static 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 3475static 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 3483static 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 3490static int CFURLRefObj_hash(CFURLRefObject *self) 3491{ 3492 /* XXXX Or should we use CFHash?? */ 3493 return (int)self->ob_itself; 3494} 3495static 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 3517static 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 3529PyTypeObject 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 3576static 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 3596static 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 3611static 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 3632static 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 3649static 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 3664static 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 3683static 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 3704static 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 3719static 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 3740static 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 3762static 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 3780static 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 3801static 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 3816static 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 3836static 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 3857static 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 3877static 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 3900static 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 3923static 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 3945static 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 3964static 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 3983static 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 4000static 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 4026static 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 4052static 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 4080static 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 4108static 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 4131static 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 4151static 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 4174static 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 4189static 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 4210static 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 4231static 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 4252static 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 4274static 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 4296static 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 4318static 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 4336static 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 4357static 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 4384static 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 4399static 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 4419static 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 4436static 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 4453static 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 4470static 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 4487static 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 4504static 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 4521static 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 4538static 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 4555static 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 4572static 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 4587static 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 4614static 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 4638static 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 4665static 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 4683static 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 4708static 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 */ 4828PyObject *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} 4843int 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 4869void 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