Home | History | Annotate | Download | only in ctl 
      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