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