/Mac/Modules/ctl/ctlsupport.py

http://unladen-swallow.googlecode.com/ · Python · 826 lines · 760 code · 45 blank · 21 comment · 2 complexity · 63b4aae63b3d5d1520dd6823f94918e1 MD5 · raw file

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