1 # This script generates a Python interface for an Apple Macintosh Manager. 2 # It uses the "bgen" package to generate C code. 3 # The function specifications are generated by scanning the mamager's header file, 4 # using the "scantools" package (customized for this particular manager). 5 6 import string 7 8 # Declarations that change for each manager 9 MACHEADERFILE = 'Controls.h' # The Apple header file 10 MODNAME = '_Ctl' # The name of the module 11 OBJECTNAME = 'Control' # The basic name of the objects used here 12 13 # The following is *usually* unchanged but may still require tuning 14 MODPREFIX = 'Ctl' # The prefix for module-wide routines 15 OBJECTTYPE = OBJECTNAME + 'Handle' # The C type used to represent them 16 OBJECTPREFIX = MODPREFIX + 'Obj' # The prefix for object methods 17 INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner 18 OUTPUTFILE = MODNAME + "module.c" # The file generated by this program 19 20 from macsupport import * 21 22 # Create the type objects 23 24 ControlHandle = OpaqueByValueType(OBJECTTYPE, OBJECTPREFIX) 25 ControlRef = ControlHandle 26 ExistingControlHandle = OpaqueByValueType(OBJECTTYPE, "CtlObj_WhichControl", "BUG") 27 28 RgnHandle = OpaqueByValueType("RgnHandle", "ResObj") 29 CCTabHandle = OpaqueByValueType("CCTabHandle", "ResObj") 30 AuxCtlHandle = OpaqueByValueType("AuxCtlHandle", "ResObj") 31 ControlPartCode = Type("ControlPartCode", "h") 32 DragConstraint = Type("DragConstraint", "H") 33 ControlVariant = Type("ControlVariant", "h") 34 IconTransformType = Type("IconTransformType", "h") 35 EventModifiers = Type("EventModifiers", "H") 36 ClickActivationResult = Type("ClickActivationResult", "l") 37 ControlButtonGraphicAlignment = Type("ControlButtonGraphicAlignment", "h") 38 ControlButtonTextAlignment = Type("ControlButtonTextAlignment", "h") 39 ControlButtonTextPlacement = Type("ControlButtonTextPlacement", "h") 40 ControlContentType = Type("ControlContentType", "h") 41 ControlFocusPart = Type("ControlFocusPart", "h") 42 43 ControlFontStyleRec = OpaqueType('ControlFontStyleRec', 'ControlFontStyle') 44 ControlFontStyleRec_ptr = ControlFontStyleRec 45 ControlID = OpaqueType('ControlID', 'PyControlID') 46 ControlID_ptr = ControlID 47 48 DragTrackingMessage = Type("DragTrackingMessage", "h") 49 DragReference = OpaqueByValueType("DragReference", "DragObj") 50 51 CFStringRef = OpaqueByValueType("CFStringRef", "CFStringRefObj") 52 CFMutableStringRef = OpaqueByValueType("CFMutableStringRef", "CFMutableStringRefObj") 53 CFDataRef = OpaqueByValueType("CFDataRef", "CFDataRefObj") 54 55 ControlTabSize = UInt16 56 ControlTabDirection = UInt16 57 ControlPopupArrowOrientation = UInt16 58 ControlPopupArrowSize = UInt16 59 ControlClockType = UInt16 60 ControlClockFlags = UInt32 61 ControlRoundButtonSize = SInt16 62 DataBrowserViewStyle = OSType 63 DataBrowserItemID = UInt32 64 DataBrowserEditCommand = UInt32 65 DataBrowserSelectionAnchorDirection = UInt32 66 DataBrowserItemState = UInt32 67 DataBrowserPropertyID = UInt32 68 DataBrowserRevealOptions = UInt8 69 DataBrowserSortOrder = UInt16 70 DataBrowserSelectionFlags = UInt32 71 DataBrowserPropertyFlags = UInt32 72 DataBrowserPropertyPart = OSType 73 DataBrowserTableViewColumnID = DataBrowserPropertyID 74 #DataBrowserTableViewColumnDesc = DataBrowserPropertyDesc 75 DataBrowserTableViewHiliteStyle = UInt32 76 DataBrowserTableViewRowIndex = UInt32 77 DataBrowserTableViewColumnIndex = UInt32 78 DataBrowserPropertyType = OSType 79 ControlDisclosureTriangleOrientation = UInt16 80 81 DataBrowserTableViewColumnDesc = OpaqueType("DataBrowserTableViewColumnDesc", 82 "DataBrowserTableViewColumnDesc") 83 DataBrowserListViewColumnDesc = OpaqueType("DataBrowserListViewColumnDesc", 84 "DataBrowserListViewColumnDesc") 85 ControlButtonContentInfo = OpaqueType("ControlButtonContentInfo", 86 "ControlButtonContentInfo") 87 ControlButtonContentInfoPtr = ControlButtonContentInfo_ptr = ControlButtonContentInfo 88 89 ControlTabEntry_ptr = OpaqueType("ControlTabEntry", "ControlTabEntry") 90 91 ControlBevelThickness = UInt16 92 ControlBevelButtonBehavior = UInt16 93 ControlBevelButtonMenuBehavior = UInt16 94 ControlBevelButtonMenuPlacement = UInt16 95 ControlPushButtonIconAlignment = UInt16 96 97 class ControlActionDefinition(Type): 98 def declare(self, name): 99 Output("%s %s;", self.typeName, name) 100 Output("UniversalProcPtr c_callback;") 101 def passInput(self, name): 102 return "myactionproc_upp" 103 def cleanup(self, name): 104 Output("setcallback((PyObject*)_self, kMyControlActionProcTag, actionProc, &c_callback);") 105 106 class ControlActionDefinitionNewControl(ControlActionDefinition): 107 def cleanup(self, name): 108 Output("setcallback(_res, kMyControlActionProcTag, liveTrackingProc, &c_callback);") 109 110 ControlActionUPP = ControlActionDefinition("PyObject*", "O") 111 ControlActionUPPNewControl = ControlActionDefinitionNewControl("PyObject*", "O") 112 ControlSliderOrientation = UInt16 113 114 115 includestuff = includestuff + """ 116 #include <Carbon/Carbon.h> 117 118 #ifdef USE_TOOLBOX_OBJECT_GLUE 119 extern PyObject *_CtlObj_New(ControlHandle); 120 extern int _CtlObj_Convert(PyObject *, ControlHandle *); 121 122 #define CtlObj_New _CtlObj_New 123 #define CtlObj_Convert _CtlObj_Convert 124 #endif 125 126 static PyObject *CtlObj_WhichControl(ControlHandle); 127 128 #define as_Control(h) ((ControlHandle)h) 129 #define as_Resource(ctl) ((Handle)ctl) 130 #define GetControlRect(ctl, rectp) GetControlBounds(ctl, rectp) 131 132 #define MAXTABS 32 /* maximum number of tabs that we support in a tabs control */ 133 /* 134 ** Parse/generate ControlFontStyleRec records 135 */ 136 #if 0 /* Not needed */ 137 static PyObject * 138 ControlFontStyle_New(ControlFontStyleRec *itself) 139 { 140 141 return Py_BuildValue("hhhhhhO&O&", itself->flags, itself->font, 142 itself->size, itself->style, itself->mode, itself->just, 143 QdRGB_New, &itself->foreColor, QdRGB_New, &itself->backColor); 144 } 145 #endif 146 147 static int 148 ControlFontStyle_Convert(PyObject *v, ControlFontStyleRec *itself) 149 { 150 return PyArg_Parse(v, "(hhhhhhO&O&)", &itself->flags, 151 &itself->font, &itself->size, &itself->style, &itself->mode, 152 &itself->just, QdRGB_Convert, &itself->foreColor, 153 QdRGB_Convert, &itself->backColor); 154 } 155 156 /* 157 ** Parse/generate ControlID records 158 */ 159 static PyObject * 160 PyControlID_New(ControlID *itself) 161 { 162 163 return Py_BuildValue("O&l", PyMac_BuildOSType, itself->signature, itself->id); 164 } 165 166 static int 167 PyControlID_Convert(PyObject *v, ControlID *itself) 168 { 169 return PyArg_Parse(v, "(O&l)", PyMac_GetOSType, &itself->signature, &itself->id); 170 } 171 172 /* 173 ** generate DataBrowserListViewColumnDesc records 174 */ 175 static int 176 DataBrowserTableViewColumnDesc_Convert(PyObject *v, DataBrowserTableViewColumnDesc *itself) 177 { 178 return PyArg_Parse(v, "(lO&l)", 179 &itself->propertyID, 180 PyMac_GetOSType, &itself->propertyType, 181 &itself->propertyFlags); 182 } 183 184 static int 185 ControlButtonContentInfo_Convert(PyObject *v, ControlButtonContentInfo *itself) 186 { 187 return PyArg_Parse(v, "(hO&)", 188 &itself->contentType, 189 OptResObj_Convert, &itself->u.iconSuite); 190 } 191 192 static int 193 DataBrowserListViewHeaderDesc_Convert(PyObject *v, DataBrowserListViewHeaderDesc *itself) 194 { 195 itself->version = kDataBrowserListViewLatestHeaderDesc; 196 return PyArg_Parse(v, "(HHhO&HO&O&)", 197 &itself->minimumWidth, 198 &itself->maximumWidth, 199 &itself->titleOffset, 200 CFStringRefObj_Convert, &itself->titleString, 201 &itself->initialOrder, 202 ControlFontStyle_Convert, &itself->btnFontStyle, 203 ControlButtonContentInfo_Convert, &itself->btnContentInfo); 204 } 205 206 static int 207 DataBrowserListViewColumnDesc_Convert(PyObject *v, DataBrowserListViewColumnDesc *itself) 208 { 209 return PyArg_Parse(v, "(O&O&)", 210 DataBrowserTableViewColumnDesc_Convert, &itself->propertyDesc, 211 DataBrowserListViewHeaderDesc_Convert, &itself->headerBtnDesc); 212 } 213 214 /* TrackControl and HandleControlClick callback support */ 215 #define kMyControlActionProcTag 'ACTN' /* not an official tag, only for internal use */ 216 static PyObject *tracker; 217 static ControlActionUPP mytracker_upp; 218 static ControlActionUPP myactionproc_upp; 219 static ControlUserPaneKeyDownUPP mykeydownproc_upp; 220 static ControlUserPaneFocusUPP myfocusproc_upp; 221 static ControlUserPaneDrawUPP mydrawproc_upp; 222 static ControlUserPaneIdleUPP myidleproc_upp; 223 static ControlUserPaneHitTestUPP myhittestproc_upp; 224 static ControlUserPaneTrackingUPP mytrackingproc_upp; 225 226 static int settrackfunc(PyObject *); /* forward */ 227 static void clrtrackfunc(void); /* forward */ 228 static int setcallback(PyObject *, OSType, PyObject *, UniversalProcPtr *); 229 """ 230 231 finalstuff = finalstuff + """ 232 static PyObject * 233 CtlObj_NewUnmanaged(ControlHandle itself) 234 { 235 ControlObject *it; 236 if (itself == NULL) return PyMac_Error(resNotFound); 237 it = PyObject_NEW(ControlObject, &Control_Type); 238 if (it == NULL) return NULL; 239 it->ob_itself = itself; 240 it->ob_callbackdict = NULL; 241 return (PyObject *)it; 242 } 243 244 static PyObject * 245 CtlObj_WhichControl(ControlHandle c) 246 { 247 PyObject *it; 248 249 if (c == NULL) 250 it = Py_None; 251 else { 252 it = (PyObject *) GetControlReference(c); 253 /* 254 ** If the refcon is zero or doesn't point back to the Python object 255 ** the control is not ours. Return a temporary object. 256 */ 257 if (it == NULL || ((ControlObject *)it)->ob_itself != c) 258 return CtlObj_NewUnmanaged(c); 259 } 260 Py_INCREF(it); 261 return it; 262 } 263 264 static int 265 settrackfunc(PyObject *obj) 266 { 267 if (tracker) { 268 PyErr_SetString(Ctl_Error, "Tracker function in use"); 269 return 0; 270 } 271 tracker = obj; 272 Py_INCREF(tracker); 273 return 1; 274 } 275 276 static void 277 clrtrackfunc(void) 278 { 279 Py_XDECREF(tracker); 280 tracker = 0; 281 } 282 283 static pascal void 284 mytracker(ControlHandle ctl, short part) 285 { 286 PyObject *args, *rv=0; 287 288 args = Py_BuildValue("(O&i)", CtlObj_WhichControl, ctl, (int)part); 289 if (args && tracker) { 290 rv = PyEval_CallObject(tracker, args); 291 Py_DECREF(args); 292 } 293 if (rv) 294 Py_DECREF(rv); 295 else { 296 PySys_WriteStderr("TrackControl or HandleControlClick: exception in tracker function\\n"); 297 PyErr_Print(); 298 } 299 } 300 301 static int 302 setcallback(PyObject *myself, OSType which, PyObject *callback, UniversalProcPtr *uppp) 303 { 304 ControlObject *self = (ControlObject *)myself; 305 char keybuf[9]; 306 307 if ( which == kMyControlActionProcTag ) 308 *uppp = (UniversalProcPtr)myactionproc_upp; 309 else if ( which == kControlUserPaneKeyDownProcTag ) 310 *uppp = (UniversalProcPtr)mykeydownproc_upp; 311 else if ( which == kControlUserPaneFocusProcTag ) 312 *uppp = (UniversalProcPtr)myfocusproc_upp; 313 else if ( which == kControlUserPaneDrawProcTag ) 314 *uppp = (UniversalProcPtr)mydrawproc_upp; 315 else if ( which == kControlUserPaneIdleProcTag ) 316 *uppp = (UniversalProcPtr)myidleproc_upp; 317 else if ( which == kControlUserPaneHitTestProcTag ) 318 *uppp = (UniversalProcPtr)myhittestproc_upp; 319 else if ( which == kControlUserPaneTrackingProcTag ) 320 *uppp = (UniversalProcPtr)mytrackingproc_upp; 321 else 322 return -1; 323 /* Only now do we test for clearing of the callback: */ 324 if ( callback == Py_None ) 325 *uppp = NULL; 326 /* Create the dict if it doesn't exist yet (so we don't get such a dict for every control) */ 327 if ( self->ob_callbackdict == NULL ) 328 if ( (self->ob_callbackdict = PyDict_New()) == NULL ) 329 return -1; 330 /* And store the Python callback */ 331 sprintf(keybuf, "%x", (unsigned)which); 332 if (PyDict_SetItemString(self->ob_callbackdict, keybuf, callback) < 0) 333 return -1; 334 return 0; 335 } 336 337 static PyObject * 338 callcallback(ControlObject *self, OSType which, PyObject *arglist) 339 { 340 char keybuf[9]; 341 PyObject *func, *rv; 342 343 sprintf(keybuf, "%x", (unsigned)which); 344 if ( self->ob_callbackdict == NULL || 345 (func = PyDict_GetItemString(self->ob_callbackdict, keybuf)) == NULL ) { 346 PySys_WriteStderr("Control callback %x without callback object\\n", (unsigned)which); 347 return NULL; 348 } 349 rv = PyEval_CallObject(func, arglist); 350 if ( rv == NULL ) { 351 PySys_WriteStderr("Exception in control callback %x handler\\n", (unsigned)which); 352 PyErr_Print(); 353 } 354 return rv; 355 } 356 357 static pascal void 358 myactionproc(ControlHandle control, SInt16 part) 359 { 360 ControlObject *ctl_obj; 361 PyObject *arglist, *rv; 362 363 ctl_obj = (ControlObject *)CtlObj_WhichControl(control); 364 arglist = Py_BuildValue("Oh", ctl_obj, part); 365 rv = callcallback(ctl_obj, kMyControlActionProcTag, arglist); 366 Py_XDECREF(arglist); 367 Py_XDECREF(rv); 368 } 369 370 static pascal ControlPartCode 371 mykeydownproc(ControlHandle control, SInt16 keyCode, SInt16 charCode, SInt16 modifiers) 372 { 373 ControlObject *ctl_obj; 374 PyObject *arglist, *rv; 375 short c_rv = 0; 376 377 ctl_obj = (ControlObject *)CtlObj_WhichControl(control); 378 arglist = Py_BuildValue("Ohhh", ctl_obj, keyCode, charCode, modifiers); 379 rv = callcallback(ctl_obj, kControlUserPaneKeyDownProcTag, arglist); 380 Py_XDECREF(arglist); 381 if ( rv ) 382 if (!PyArg_Parse(rv, "h", &c_rv)) 383 PyErr_Clear(); 384 Py_XDECREF(rv); 385 return (ControlPartCode)c_rv; 386 } 387 388 static pascal ControlPartCode 389 myfocusproc(ControlHandle control, ControlPartCode part) 390 { 391 ControlObject *ctl_obj; 392 PyObject *arglist, *rv; 393 short c_rv = kControlFocusNoPart; 394 395 ctl_obj = (ControlObject *)CtlObj_WhichControl(control); 396 arglist = Py_BuildValue("Oh", ctl_obj, part); 397 rv = callcallback(ctl_obj, kControlUserPaneFocusProcTag, arglist); 398 Py_XDECREF(arglist); 399 if ( rv ) 400 if (!PyArg_Parse(rv, "h", &c_rv)) 401 PyErr_Clear(); 402 Py_XDECREF(rv); 403 return (ControlPartCode)c_rv; 404 } 405 406 static pascal void 407 mydrawproc(ControlHandle control, SInt16 part) 408 { 409 ControlObject *ctl_obj; 410 PyObject *arglist, *rv; 411 412 ctl_obj = (ControlObject *)CtlObj_WhichControl(control); 413 arglist = Py_BuildValue("Oh", ctl_obj, part); 414 rv = callcallback(ctl_obj, kControlUserPaneDrawProcTag, arglist); 415 Py_XDECREF(arglist); 416 Py_XDECREF(rv); 417 } 418 419 static pascal void 420 myidleproc(ControlHandle control) 421 { 422 ControlObject *ctl_obj; 423 PyObject *arglist, *rv; 424 425 ctl_obj = (ControlObject *)CtlObj_WhichControl(control); 426 arglist = Py_BuildValue("O", ctl_obj); 427 rv = callcallback(ctl_obj, kControlUserPaneIdleProcTag, arglist); 428 Py_XDECREF(arglist); 429 Py_XDECREF(rv); 430 } 431 432 static pascal ControlPartCode 433 myhittestproc(ControlHandle control, Point where) 434 { 435 ControlObject *ctl_obj; 436 PyObject *arglist, *rv; 437 short c_rv = -1; 438 439 ctl_obj = (ControlObject *)CtlObj_WhichControl(control); 440 arglist = Py_BuildValue("OO&", ctl_obj, PyMac_BuildPoint, where); 441 rv = callcallback(ctl_obj, kControlUserPaneHitTestProcTag, arglist); 442 Py_XDECREF(arglist); 443 /* Ignore errors, nothing we can do about them */ 444 if ( rv ) 445 if (!PyArg_Parse(rv, "h", &c_rv)) 446 PyErr_Clear(); 447 Py_XDECREF(rv); 448 return (ControlPartCode)c_rv; 449 } 450 451 static pascal ControlPartCode 452 mytrackingproc(ControlHandle control, Point startPt, ControlActionUPP actionProc) 453 { 454 ControlObject *ctl_obj; 455 PyObject *arglist, *rv; 456 short c_rv = -1; 457 458 ctl_obj = (ControlObject *)CtlObj_WhichControl(control); 459 /* We cannot pass the actionProc without lots of work */ 460 arglist = Py_BuildValue("OO&", ctl_obj, PyMac_BuildPoint, startPt); 461 rv = callcallback(ctl_obj, kControlUserPaneTrackingProcTag, arglist); 462 Py_XDECREF(arglist); 463 if ( rv ) 464 if (!PyArg_Parse(rv, "h", &c_rv)) 465 PyErr_Clear(); 466 Py_XDECREF(rv); 467 return (ControlPartCode)c_rv; 468 } 469 """ 470 471 initstuff = initstuff + """ 472 mytracker_upp = NewControlActionUPP(mytracker); 473 myactionproc_upp = NewControlActionUPP(myactionproc); 474 mykeydownproc_upp = NewControlUserPaneKeyDownUPP(mykeydownproc); 475 myfocusproc_upp = NewControlUserPaneFocusUPP(myfocusproc); 476 mydrawproc_upp = NewControlUserPaneDrawUPP(mydrawproc); 477 myidleproc_upp = NewControlUserPaneIdleUPP(myidleproc); 478 myhittestproc_upp = NewControlUserPaneHitTestUPP(myhittestproc); 479 mytrackingproc_upp = NewControlUserPaneTrackingUPP(mytrackingproc); 480 PyMac_INIT_TOOLBOX_OBJECT_NEW(ControlHandle, CtlObj_New); 481 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(ControlHandle, CtlObj_Convert); 482 """ 483 484 class MyObjectDefinition(PEP253Mixin, ObjectIdentityMixin, GlobalObjectDefinition): 485 def outputStructMembers(self): 486 GlobalObjectDefinition.outputStructMembers(self) 487 Output("PyObject *ob_callbackdict;") 488 def outputCheckNewArg(self): 489 Output("if (itself == NULL) return PyMac_Error(resNotFound);") 490 def outputInitStructMembers(self): 491 GlobalObjectDefinition.outputInitStructMembers(self) 492 Output("SetControlReference(itself, (long)it);") 493 Output("it->ob_callbackdict = NULL;") 494 def outputCleanupStructMembers(self): 495 Output("Py_XDECREF(self->ob_callbackdict);") 496 Output("if (self->ob_itself)SetControlReference(self->ob_itself, (long)0); /* Make it forget about us */") 497 498 # Create the generator groups and link them 499 module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff) 500 object = MyObjectDefinition(OBJECTNAME, OBJECTPREFIX, OBJECTTYPE) 501 module.addobject(object) 502 503 # Create the generator classes used to populate the lists 504 Function = OSErrWeakLinkFunctionGenerator 505 Method = OSErrWeakLinkMethodGenerator 506 507 # Create and populate the lists 508 functions = [] 509 methods = [] 510 execfile(INPUTFILE) 511 execfile('ctledit.py') 512 513 # add the populated lists to the generator groups 514 for f in functions: module.add(f) 515 for f in methods: object.add(f) 516 517 # Manual generator for TrackControl, due to callback ideosyncracies 518 trackcontrol_body = """ 519 ControlPartCode _rv; 520 Point startPoint; 521 ControlActionUPP upp = 0; 522 PyObject *callback = 0; 523 524 if (!PyArg_ParseTuple(_args, "O&|O", 525 PyMac_GetPoint, &startPoint, &callback)) 526 return NULL; 527 if (callback && callback != Py_None) { 528 if (PyInt_Check(callback) && PyInt_AS_LONG(callback) == -1) 529 upp = (ControlActionUPP)-1; 530 else { 531 settrackfunc(callback); 532 upp = mytracker_upp; 533 } 534 } 535 _rv = TrackControl(_self->ob_itself, 536 startPoint, 537 upp); 538 clrtrackfunc(); 539 _res = Py_BuildValue("h", 540 _rv); 541 return _res; 542 """ 543 544 f = ManualGenerator("TrackControl", trackcontrol_body); 545 f.docstring = lambda: "(Point startPoint [,trackercallback]) -> (ControlPartCode _rv)" 546 object.add(f) 547 548 # CJW - added 5/12/99 549 # Manual generator for HandleControlClick, as for TrackControl 550 handlecontrolclick_body = """ 551 ControlPartCode _rv; 552 Point startPoint; 553 SInt16 modifiers; 554 ControlActionUPP upp = 0; 555 PyObject *callback = 0; 556 557 if (!PyArg_ParseTuple(_args, "O&h|O", 558 PyMac_GetPoint, &startPoint, 559 &modifiers, 560 &callback)) 561 return NULL; 562 if (callback && callback != Py_None) { 563 if (PyInt_Check(callback) && PyInt_AS_LONG(callback) == -1) 564 upp = (ControlActionUPP)-1; 565 else { 566 settrackfunc(callback); 567 upp = mytracker_upp; 568 } 569 } 570 _rv = HandleControlClick(_self->ob_itself, 571 startPoint, 572 modifiers, 573 upp); 574 clrtrackfunc(); 575 _res = Py_BuildValue("h", 576 _rv); 577 return _res; 578 """ 579 580 f = ManualGenerator("HandleControlClick", handlecontrolclick_body); 581 f.docstring = lambda: "(Point startPoint, Integer modifiers, [,trackercallback]) -> (ControlPartCode _rv)" 582 object.add(f) 583 584 # Manual Generator for SetControlData 585 setcontroldata_body = """ 586 OSErr _err; 587 ControlPartCode inPart; 588 ResType inTagName; 589 Size bufferSize; 590 Ptr buffer; 591 592 if (!PyArg_ParseTuple(_args, "hO&s#", 593 &inPart, 594 PyMac_GetOSType, &inTagName, 595 &buffer, &bufferSize)) 596 return NULL; 597 598 _err = SetControlData(_self->ob_itself, 599 inPart, 600 inTagName, 601 bufferSize, 602 buffer); 603 604 if (_err != noErr) 605 return PyMac_Error(_err); 606 _res = Py_None; 607 return _res; 608 """ 609 610 f = ManualGenerator("SetControlData", setcontroldata_body); 611 f.docstring = lambda: "(stuff) -> None" 612 object.add(f) 613 614 # Manual Generator for GetControlData 615 getcontroldata_body = """ 616 OSErr _err; 617 ControlPartCode inPart; 618 ResType inTagName; 619 Size bufferSize; 620 Ptr buffer; 621 Size outSize; 622 623 if (!PyArg_ParseTuple(_args, "hO&", 624 &inPart, 625 PyMac_GetOSType, &inTagName)) 626 return NULL; 627 628 /* allocate a buffer for the data */ 629 _err = GetControlDataSize(_self->ob_itself, 630 inPart, 631 inTagName, 632 &bufferSize); 633 if (_err != noErr) 634 return PyMac_Error(_err); 635 buffer = PyMem_NEW(char, bufferSize); 636 if (buffer == NULL) 637 return PyErr_NoMemory(); 638 639 _err = GetControlData(_self->ob_itself, 640 inPart, 641 inTagName, 642 bufferSize, 643 buffer, 644 &outSize); 645 646 if (_err != noErr) { 647 PyMem_DEL(buffer); 648 return PyMac_Error(_err); 649 } 650 _res = Py_BuildValue("s#", buffer, outSize); 651 PyMem_DEL(buffer); 652 return _res; 653 """ 654 655 f = ManualGenerator("GetControlData", getcontroldata_body); 656 f.docstring = lambda: "(part, type) -> String" 657 object.add(f) 658 659 # Manual Generator for SetControlData_Handle 660 setcontroldata_handle_body = """ 661 OSErr _err; 662 ControlPartCode inPart; 663 ResType inTagName; 664 Handle buffer; 665 666 if (!PyArg_ParseTuple(_args, "hO&O&", 667 &inPart, 668 PyMac_GetOSType, &inTagName, 669 OptResObj_Convert, &buffer)) 670 return NULL; 671 672 _err = SetControlData(_self->ob_itself, 673 inPart, 674 inTagName, 675 sizeof(buffer), 676 (Ptr)&buffer); 677 678 if (_err != noErr) 679 return PyMac_Error(_err); 680 _res = Py_None; 681 return _res; 682 """ 683 684 f = ManualGenerator("SetControlData_Handle", setcontroldata_handle_body); 685 f.docstring = lambda: "(ResObj) -> None" 686 object.add(f) 687 688 # Manual Generator for GetControlData_Handle 689 getcontroldata_handle_body = """ 690 OSErr _err; 691 ControlPartCode inPart; 692 ResType inTagName; 693 Size bufferSize; 694 Handle hdl; 695 696 if (!PyArg_ParseTuple(_args, "hO&", 697 &inPart, 698 PyMac_GetOSType, &inTagName)) 699 return NULL; 700 701 /* Check it is handle-sized */ 702 _err = GetControlDataSize(_self->ob_itself, 703 inPart, 704 inTagName, 705 &bufferSize); 706 if (_err != noErr) 707 return PyMac_Error(_err); 708 if (bufferSize != sizeof(Handle)) { 709 PyErr_SetString(Ctl_Error, "GetControlDataSize() != sizeof(Handle)"); 710 return NULL; 711 } 712 713 _err = GetControlData(_self->ob_itself, 714 inPart, 715 inTagName, 716 sizeof(Handle), 717 (Ptr)&hdl, 718 &bufferSize); 719 720 if (_err != noErr) { 721 return PyMac_Error(_err); 722 } 723 _res = Py_BuildValue("O&", OptResObj_New, hdl); 724 return _res; 725 """ 726 727 f = ManualGenerator("GetControlData_Handle", getcontroldata_handle_body); 728 f.docstring = lambda: "(part, type) -> ResObj" 729 object.add(f) 730 731 # Manual Generator for SetControlData_Callback 732 setcontroldata_callback_body = """ 733 OSErr _err; 734 ControlPartCode inPart; 735 ResType inTagName; 736 PyObject *callback; 737 UniversalProcPtr c_callback; 738 739 if (!PyArg_ParseTuple(_args, "hO&O", 740 &inPart, 741 PyMac_GetOSType, &inTagName, 742 &callback)) 743 return NULL; 744 745 if ( setcallback((PyObject *)_self, inTagName, callback, &c_callback) < 0 ) 746 return NULL; 747 _err = SetControlData(_self->ob_itself, 748 inPart, 749 inTagName, 750 sizeof(c_callback), 751 (Ptr)&c_callback); 752 753 if (_err != noErr) 754 return PyMac_Error(_err); 755 _res = Py_None; 756 return _res; 757 """ 758 759 f = ManualGenerator("SetControlData_Callback", setcontroldata_callback_body); 760 f.docstring = lambda: "(callbackfunc) -> None" 761 object.add(f) 762 763 764 765 createtabscontrol_body = """\ 766 OSStatus _err; 767 WindowPtr window; 768 Rect boundsRect; 769 UInt16 size; 770 UInt16 direction; 771 int i; 772 UInt16 numTabs; 773 ControlTabEntry tabArray[MAXTABS]; 774 ControlHandle outControl; 775 PyObject *tabArrayObj, *tabEntry; 776 777 #ifndef CreateTabsControl 778 PyMac_PRECHECK(CreateTabsControl); 779 #endif 780 if (!PyArg_ParseTuple(_args, "O&O&HHO", 781 WinObj_Convert, &window, 782 PyMac_GetRect, &boundsRect, 783 &size, 784 &direction, 785 &tabArrayObj)) 786 return NULL; 787 788 i = PySequence_Length(tabArrayObj); 789 if (i == -1) 790 return NULL; 791 if (i > MAXTABS) { 792 PyErr_SetString(Ctl_Error, "Too many tabs"); 793 return NULL; 794 } 795 numTabs = i; 796 for (i=0; i<numTabs; i++) { 797 tabEntry = PySequence_GetItem(tabArrayObj, i); 798 if (tabEntry == NULL) 799 return NULL; 800 if (!PyArg_Parse(tabEntry, "(O&O&B)", 801 ControlButtonContentInfo_Convert, &tabArray[i].icon, 802 CFStringRefObj_Convert, &tabArray[i].name, 803 &tabArray[i].enabled 804 )) 805 return NULL; 806 } 807 808 _err = CreateTabsControl(window, 809 &boundsRect, 810 size, 811 direction, 812 numTabs, 813 tabArray, 814 &outControl); 815 if (_err != noErr) return PyMac_Error(_err); 816 _res = Py_BuildValue("O&", 817 CtlObj_New, outControl); 818 return _res;""" 819 820 f = ManualGenerator("CreateTabsControl", createtabscontrol_body) 821 f.docstring = lambda: "(WindowPtr window, Rect boundsRect, UInt16 size, UInt16 direction, ControlTabEntry tabArray) -> (ControlHandle outControl)" 822 module.add(f) 823 824 # generate output (open the output file as late as possible) 825 SetOutputFileName(OUTPUTFILE) 826 module.generate() 827