Mac/Modules/ctl/ctlsupport.py

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