/Mac/Modules/qt/_Qtmodule.c

http://unladen-swallow.googlecode.com/ · C · 28091 lines · 26705 code · 1344 blank · 42 comment · 1567 complexity · 22bb6d839073acbab8d527a7d47c5c11 MD5 · raw file

Large files are truncated click here to view the full file

  1. /* =========================== Module _Qt =========================== */
  2. #include "Python.h"
  3. #ifndef __LP64__
  4. #include "pymactoolbox.h"
  5. /* Macro to test whether a weak-loaded CFM function exists */
  6. #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
  7. PyErr_SetString(PyExc_NotImplementedError, \
  8. "Not available in this shared library/OS version"); \
  9. return NULL; \
  10. }} while(0)
  11. #include <QuickTime/QuickTime.h>
  12. #ifdef USE_TOOLBOX_OBJECT_GLUE
  13. extern PyObject *_TrackObj_New(Track);
  14. extern int _TrackObj_Convert(PyObject *, Track *);
  15. extern PyObject *_MovieObj_New(Movie);
  16. extern int _MovieObj_Convert(PyObject *, Movie *);
  17. extern PyObject *_MovieCtlObj_New(MovieController);
  18. extern int _MovieCtlObj_Convert(PyObject *, MovieController *);
  19. extern PyObject *_TimeBaseObj_New(TimeBase);
  20. extern int _TimeBaseObj_Convert(PyObject *, TimeBase *);
  21. extern PyObject *_UserDataObj_New(UserData);
  22. extern int _UserDataObj_Convert(PyObject *, UserData *);
  23. extern PyObject *_MediaObj_New(Media);
  24. extern int _MediaObj_Convert(PyObject *, Media *);
  25. #define TrackObj_New _TrackObj_New
  26. #define TrackObj_Convert _TrackObj_Convert
  27. #define MovieObj_New _MovieObj_New
  28. #define MovieObj_Convert _MovieObj_Convert
  29. #define MovieCtlObj_New _MovieCtlObj_New
  30. #define MovieCtlObj_Convert _MovieCtlObj_Convert
  31. #define TimeBaseObj_New _TimeBaseObj_New
  32. #define TimeBaseObj_Convert _TimeBaseObj_Convert
  33. #define UserDataObj_New _UserDataObj_New
  34. #define UserDataObj_Convert _UserDataObj_Convert
  35. #define MediaObj_New _MediaObj_New
  36. #define MediaObj_Convert _MediaObj_Convert
  37. #endif
  38. /* Macro to allow us to GetNextInterestingTime without duration */
  39. #define GetMediaNextInterestingTimeOnly(media, flags, time, rate, rv) GetMediaNextInterestingTime(media, flags, time, rate, rv, NULL)
  40. /*
  41. ** Parse/generate time records
  42. */
  43. static PyObject *
  44. QtTimeRecord_New(TimeRecord *itself)
  45. {
  46. if (itself->base)
  47. return Py_BuildValue("O&lO&", PyMac_Buildwide, &itself->value, itself->scale,
  48. TimeBaseObj_New, itself->base);
  49. else
  50. return Py_BuildValue("O&lO", PyMac_Buildwide, &itself->value, itself->scale,
  51. Py_None);
  52. }
  53. static int
  54. QtTimeRecord_Convert(PyObject *v, TimeRecord *p_itself)
  55. {
  56. PyObject *base = NULL;
  57. if( !PyArg_ParseTuple(v, "O&l|O", PyMac_Getwide, &p_itself->value, &p_itself->scale,
  58. &base) )
  59. return 0;
  60. if ( base == NULL || base == Py_None )
  61. p_itself->base = NULL;
  62. else
  63. if ( !TimeBaseObj_Convert(base, &p_itself->base) )
  64. return 0;
  65. return 1;
  66. }
  67. static int
  68. QtMusicMIDIPacket_Convert(PyObject *v, MusicMIDIPacket *p_itself)
  69. {
  70. int dummy;
  71. if( !PyArg_ParseTuple(v, "hls#", &p_itself->length, &p_itself->reserved, p_itself->data, dummy) )
  72. return 0;
  73. return 1;
  74. }
  75. static PyObject *Qt_Error;
  76. /* -------------------- Object type IdleManager --------------------- */
  77. PyTypeObject IdleManager_Type;
  78. #define IdleManagerObj_Check(x) ((x)->ob_type == &IdleManager_Type || PyObject_TypeCheck((x), &IdleManager_Type))
  79. typedef struct IdleManagerObject {
  80. PyObject_HEAD
  81. IdleManager ob_itself;
  82. } IdleManagerObject;
  83. PyObject *IdleManagerObj_New(IdleManager itself)
  84. {
  85. IdleManagerObject *it;
  86. if (itself == NULL) {
  87. PyErr_SetString(Qt_Error,"Cannot create IdleManager from NULL pointer");
  88. return NULL;
  89. }
  90. it = PyObject_NEW(IdleManagerObject, &IdleManager_Type);
  91. if (it == NULL) return NULL;
  92. it->ob_itself = itself;
  93. return (PyObject *)it;
  94. }
  95. int IdleManagerObj_Convert(PyObject *v, IdleManager *p_itself)
  96. {
  97. if (v == Py_None)
  98. {
  99. *p_itself = NULL;
  100. return 1;
  101. }
  102. if (!IdleManagerObj_Check(v))
  103. {
  104. PyErr_SetString(PyExc_TypeError, "IdleManager required");
  105. return 0;
  106. }
  107. *p_itself = ((IdleManagerObject *)v)->ob_itself;
  108. return 1;
  109. }
  110. static void IdleManagerObj_dealloc(IdleManagerObject *self)
  111. {
  112. /* Cleanup of self->ob_itself goes here */
  113. self->ob_type->tp_free((PyObject *)self);
  114. }
  115. static PyMethodDef IdleManagerObj_methods[] = {
  116. {NULL, NULL, 0}
  117. };
  118. #define IdleManagerObj_getsetlist NULL
  119. #define IdleManagerObj_compare NULL
  120. #define IdleManagerObj_repr NULL
  121. #define IdleManagerObj_hash NULL
  122. #define IdleManagerObj_tp_init 0
  123. #define IdleManagerObj_tp_alloc PyType_GenericAlloc
  124. static PyObject *IdleManagerObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
  125. {
  126. PyObject *_self;
  127. IdleManager itself;
  128. char *kw[] = {"itself", 0};
  129. if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, IdleManagerObj_Convert, &itself)) return NULL;
  130. if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
  131. ((IdleManagerObject *)_self)->ob_itself = itself;
  132. return _self;
  133. }
  134. #define IdleManagerObj_tp_free PyObject_Del
  135. PyTypeObject IdleManager_Type = {
  136. PyObject_HEAD_INIT(NULL)
  137. 0, /*ob_size*/
  138. "_Qt.IdleManager", /*tp_name*/
  139. sizeof(IdleManagerObject), /*tp_basicsize*/
  140. 0, /*tp_itemsize*/
  141. /* methods */
  142. (destructor) IdleManagerObj_dealloc, /*tp_dealloc*/
  143. 0, /*tp_print*/
  144. (getattrfunc)0, /*tp_getattr*/
  145. (setattrfunc)0, /*tp_setattr*/
  146. (cmpfunc) IdleManagerObj_compare, /*tp_compare*/
  147. (reprfunc) IdleManagerObj_repr, /*tp_repr*/
  148. (PyNumberMethods *)0, /* tp_as_number */
  149. (PySequenceMethods *)0, /* tp_as_sequence */
  150. (PyMappingMethods *)0, /* tp_as_mapping */
  151. (hashfunc) IdleManagerObj_hash, /*tp_hash*/
  152. 0, /*tp_call*/
  153. 0, /*tp_str*/
  154. PyObject_GenericGetAttr, /*tp_getattro*/
  155. PyObject_GenericSetAttr, /*tp_setattro */
  156. 0, /*tp_as_buffer*/
  157. Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
  158. 0, /*tp_doc*/
  159. 0, /*tp_traverse*/
  160. 0, /*tp_clear*/
  161. 0, /*tp_richcompare*/
  162. 0, /*tp_weaklistoffset*/
  163. 0, /*tp_iter*/
  164. 0, /*tp_iternext*/
  165. IdleManagerObj_methods, /* tp_methods */
  166. 0, /*tp_members*/
  167. IdleManagerObj_getsetlist, /*tp_getset*/
  168. 0, /*tp_base*/
  169. 0, /*tp_dict*/
  170. 0, /*tp_descr_get*/
  171. 0, /*tp_descr_set*/
  172. 0, /*tp_dictoffset*/
  173. IdleManagerObj_tp_init, /* tp_init */
  174. IdleManagerObj_tp_alloc, /* tp_alloc */
  175. IdleManagerObj_tp_new, /* tp_new */
  176. IdleManagerObj_tp_free, /* tp_free */
  177. };
  178. /* ------------------ End object type IdleManager ------------------- */
  179. /* ------------------ Object type MovieController ------------------- */
  180. PyTypeObject MovieController_Type;
  181. #define MovieCtlObj_Check(x) ((x)->ob_type == &MovieController_Type || PyObject_TypeCheck((x), &MovieController_Type))
  182. typedef struct MovieControllerObject {
  183. PyObject_HEAD
  184. MovieController ob_itself;
  185. } MovieControllerObject;
  186. PyObject *MovieCtlObj_New(MovieController itself)
  187. {
  188. MovieControllerObject *it;
  189. if (itself == NULL) {
  190. PyErr_SetString(Qt_Error,"Cannot create MovieController from NULL pointer");
  191. return NULL;
  192. }
  193. it = PyObject_NEW(MovieControllerObject, &MovieController_Type);
  194. if (it == NULL) return NULL;
  195. it->ob_itself = itself;
  196. return (PyObject *)it;
  197. }
  198. int MovieCtlObj_Convert(PyObject *v, MovieController *p_itself)
  199. {
  200. if (v == Py_None)
  201. {
  202. *p_itself = NULL;
  203. return 1;
  204. }
  205. if (!MovieCtlObj_Check(v))
  206. {
  207. PyErr_SetString(PyExc_TypeError, "MovieController required");
  208. return 0;
  209. }
  210. *p_itself = ((MovieControllerObject *)v)->ob_itself;
  211. return 1;
  212. }
  213. static void MovieCtlObj_dealloc(MovieControllerObject *self)
  214. {
  215. if (self->ob_itself) DisposeMovieController(self->ob_itself);
  216. self->ob_type->tp_free((PyObject *)self);
  217. }
  218. static PyObject *MovieCtlObj_MCSetMovie(MovieControllerObject *_self, PyObject *_args)
  219. {
  220. PyObject *_res = NULL;
  221. ComponentResult _rv;
  222. Movie theMovie;
  223. WindowPtr movieWindow;
  224. Point where;
  225. #ifndef MCSetMovie
  226. PyMac_PRECHECK(MCSetMovie);
  227. #endif
  228. if (!PyArg_ParseTuple(_args, "O&O&O&",
  229. MovieObj_Convert, &theMovie,
  230. WinObj_Convert, &movieWindow,
  231. PyMac_GetPoint, &where))
  232. return NULL;
  233. _rv = MCSetMovie(_self->ob_itself,
  234. theMovie,
  235. movieWindow,
  236. where);
  237. _res = Py_BuildValue("l",
  238. _rv);
  239. return _res;
  240. }
  241. static PyObject *MovieCtlObj_MCGetIndMovie(MovieControllerObject *_self, PyObject *_args)
  242. {
  243. PyObject *_res = NULL;
  244. Movie _rv;
  245. short index;
  246. #ifndef MCGetIndMovie
  247. PyMac_PRECHECK(MCGetIndMovie);
  248. #endif
  249. if (!PyArg_ParseTuple(_args, "h",
  250. &index))
  251. return NULL;
  252. _rv = MCGetIndMovie(_self->ob_itself,
  253. index);
  254. _res = Py_BuildValue("O&",
  255. MovieObj_New, _rv);
  256. return _res;
  257. }
  258. static PyObject *MovieCtlObj_MCRemoveAllMovies(MovieControllerObject *_self, PyObject *_args)
  259. {
  260. PyObject *_res = NULL;
  261. ComponentResult _rv;
  262. #ifndef MCRemoveAllMovies
  263. PyMac_PRECHECK(MCRemoveAllMovies);
  264. #endif
  265. if (!PyArg_ParseTuple(_args, ""))
  266. return NULL;
  267. _rv = MCRemoveAllMovies(_self->ob_itself);
  268. _res = Py_BuildValue("l",
  269. _rv);
  270. return _res;
  271. }
  272. static PyObject *MovieCtlObj_MCRemoveAMovie(MovieControllerObject *_self, PyObject *_args)
  273. {
  274. PyObject *_res = NULL;
  275. ComponentResult _rv;
  276. Movie m;
  277. #ifndef MCRemoveAMovie
  278. PyMac_PRECHECK(MCRemoveAMovie);
  279. #endif
  280. if (!PyArg_ParseTuple(_args, "O&",
  281. MovieObj_Convert, &m))
  282. return NULL;
  283. _rv = MCRemoveAMovie(_self->ob_itself,
  284. m);
  285. _res = Py_BuildValue("l",
  286. _rv);
  287. return _res;
  288. }
  289. static PyObject *MovieCtlObj_MCRemoveMovie(MovieControllerObject *_self, PyObject *_args)
  290. {
  291. PyObject *_res = NULL;
  292. ComponentResult _rv;
  293. #ifndef MCRemoveMovie
  294. PyMac_PRECHECK(MCRemoveMovie);
  295. #endif
  296. if (!PyArg_ParseTuple(_args, ""))
  297. return NULL;
  298. _rv = MCRemoveMovie(_self->ob_itself);
  299. _res = Py_BuildValue("l",
  300. _rv);
  301. return _res;
  302. }
  303. static PyObject *MovieCtlObj_MCIsPlayerEvent(MovieControllerObject *_self, PyObject *_args)
  304. {
  305. PyObject *_res = NULL;
  306. ComponentResult _rv;
  307. EventRecord e;
  308. #ifndef MCIsPlayerEvent
  309. PyMac_PRECHECK(MCIsPlayerEvent);
  310. #endif
  311. if (!PyArg_ParseTuple(_args, "O&",
  312. PyMac_GetEventRecord, &e))
  313. return NULL;
  314. _rv = MCIsPlayerEvent(_self->ob_itself,
  315. &e);
  316. _res = Py_BuildValue("l",
  317. _rv);
  318. return _res;
  319. }
  320. static PyObject *MovieCtlObj_MCDoAction(MovieControllerObject *_self, PyObject *_args)
  321. {
  322. PyObject *_res = NULL;
  323. ComponentResult _rv;
  324. short action;
  325. void * params;
  326. #ifndef MCDoAction
  327. PyMac_PRECHECK(MCDoAction);
  328. #endif
  329. if (!PyArg_ParseTuple(_args, "hs",
  330. &action,
  331. &params))
  332. return NULL;
  333. _rv = MCDoAction(_self->ob_itself,
  334. action,
  335. params);
  336. _res = Py_BuildValue("l",
  337. _rv);
  338. return _res;
  339. }
  340. static PyObject *MovieCtlObj_MCSetControllerAttached(MovieControllerObject *_self, PyObject *_args)
  341. {
  342. PyObject *_res = NULL;
  343. ComponentResult _rv;
  344. Boolean attach;
  345. #ifndef MCSetControllerAttached
  346. PyMac_PRECHECK(MCSetControllerAttached);
  347. #endif
  348. if (!PyArg_ParseTuple(_args, "b",
  349. &attach))
  350. return NULL;
  351. _rv = MCSetControllerAttached(_self->ob_itself,
  352. attach);
  353. _res = Py_BuildValue("l",
  354. _rv);
  355. return _res;
  356. }
  357. static PyObject *MovieCtlObj_MCIsControllerAttached(MovieControllerObject *_self, PyObject *_args)
  358. {
  359. PyObject *_res = NULL;
  360. ComponentResult _rv;
  361. #ifndef MCIsControllerAttached
  362. PyMac_PRECHECK(MCIsControllerAttached);
  363. #endif
  364. if (!PyArg_ParseTuple(_args, ""))
  365. return NULL;
  366. _rv = MCIsControllerAttached(_self->ob_itself);
  367. _res = Py_BuildValue("l",
  368. _rv);
  369. return _res;
  370. }
  371. static PyObject *MovieCtlObj_MCSetControllerPort(MovieControllerObject *_self, PyObject *_args)
  372. {
  373. PyObject *_res = NULL;
  374. ComponentResult _rv;
  375. CGrafPtr gp;
  376. #ifndef MCSetControllerPort
  377. PyMac_PRECHECK(MCSetControllerPort);
  378. #endif
  379. if (!PyArg_ParseTuple(_args, "O&",
  380. GrafObj_Convert, &gp))
  381. return NULL;
  382. _rv = MCSetControllerPort(_self->ob_itself,
  383. gp);
  384. _res = Py_BuildValue("l",
  385. _rv);
  386. return _res;
  387. }
  388. static PyObject *MovieCtlObj_MCGetControllerPort(MovieControllerObject *_self, PyObject *_args)
  389. {
  390. PyObject *_res = NULL;
  391. CGrafPtr _rv;
  392. #ifndef MCGetControllerPort
  393. PyMac_PRECHECK(MCGetControllerPort);
  394. #endif
  395. if (!PyArg_ParseTuple(_args, ""))
  396. return NULL;
  397. _rv = MCGetControllerPort(_self->ob_itself);
  398. _res = Py_BuildValue("O&",
  399. GrafObj_New, _rv);
  400. return _res;
  401. }
  402. static PyObject *MovieCtlObj_MCSetVisible(MovieControllerObject *_self, PyObject *_args)
  403. {
  404. PyObject *_res = NULL;
  405. ComponentResult _rv;
  406. Boolean visible;
  407. #ifndef MCSetVisible
  408. PyMac_PRECHECK(MCSetVisible);
  409. #endif
  410. if (!PyArg_ParseTuple(_args, "b",
  411. &visible))
  412. return NULL;
  413. _rv = MCSetVisible(_self->ob_itself,
  414. visible);
  415. _res = Py_BuildValue("l",
  416. _rv);
  417. return _res;
  418. }
  419. static PyObject *MovieCtlObj_MCGetVisible(MovieControllerObject *_self, PyObject *_args)
  420. {
  421. PyObject *_res = NULL;
  422. ComponentResult _rv;
  423. #ifndef MCGetVisible
  424. PyMac_PRECHECK(MCGetVisible);
  425. #endif
  426. if (!PyArg_ParseTuple(_args, ""))
  427. return NULL;
  428. _rv = MCGetVisible(_self->ob_itself);
  429. _res = Py_BuildValue("l",
  430. _rv);
  431. return _res;
  432. }
  433. static PyObject *MovieCtlObj_MCGetControllerBoundsRect(MovieControllerObject *_self, PyObject *_args)
  434. {
  435. PyObject *_res = NULL;
  436. ComponentResult _rv;
  437. Rect bounds;
  438. #ifndef MCGetControllerBoundsRect
  439. PyMac_PRECHECK(MCGetControllerBoundsRect);
  440. #endif
  441. if (!PyArg_ParseTuple(_args, ""))
  442. return NULL;
  443. _rv = MCGetControllerBoundsRect(_self->ob_itself,
  444. &bounds);
  445. _res = Py_BuildValue("lO&",
  446. _rv,
  447. PyMac_BuildRect, &bounds);
  448. return _res;
  449. }
  450. static PyObject *MovieCtlObj_MCSetControllerBoundsRect(MovieControllerObject *_self, PyObject *_args)
  451. {
  452. PyObject *_res = NULL;
  453. ComponentResult _rv;
  454. Rect bounds;
  455. #ifndef MCSetControllerBoundsRect
  456. PyMac_PRECHECK(MCSetControllerBoundsRect);
  457. #endif
  458. if (!PyArg_ParseTuple(_args, "O&",
  459. PyMac_GetRect, &bounds))
  460. return NULL;
  461. _rv = MCSetControllerBoundsRect(_self->ob_itself,
  462. &bounds);
  463. _res = Py_BuildValue("l",
  464. _rv);
  465. return _res;
  466. }
  467. static PyObject *MovieCtlObj_MCGetControllerBoundsRgn(MovieControllerObject *_self, PyObject *_args)
  468. {
  469. PyObject *_res = NULL;
  470. RgnHandle _rv;
  471. #ifndef MCGetControllerBoundsRgn
  472. PyMac_PRECHECK(MCGetControllerBoundsRgn);
  473. #endif
  474. if (!PyArg_ParseTuple(_args, ""))
  475. return NULL;
  476. _rv = MCGetControllerBoundsRgn(_self->ob_itself);
  477. _res = Py_BuildValue("O&",
  478. ResObj_New, _rv);
  479. return _res;
  480. }
  481. static PyObject *MovieCtlObj_MCGetWindowRgn(MovieControllerObject *_self, PyObject *_args)
  482. {
  483. PyObject *_res = NULL;
  484. RgnHandle _rv;
  485. WindowPtr w;
  486. #ifndef MCGetWindowRgn
  487. PyMac_PRECHECK(MCGetWindowRgn);
  488. #endif
  489. if (!PyArg_ParseTuple(_args, "O&",
  490. WinObj_Convert, &w))
  491. return NULL;
  492. _rv = MCGetWindowRgn(_self->ob_itself,
  493. w);
  494. _res = Py_BuildValue("O&",
  495. ResObj_New, _rv);
  496. return _res;
  497. }
  498. static PyObject *MovieCtlObj_MCMovieChanged(MovieControllerObject *_self, PyObject *_args)
  499. {
  500. PyObject *_res = NULL;
  501. ComponentResult _rv;
  502. Movie m;
  503. #ifndef MCMovieChanged
  504. PyMac_PRECHECK(MCMovieChanged);
  505. #endif
  506. if (!PyArg_ParseTuple(_args, "O&",
  507. MovieObj_Convert, &m))
  508. return NULL;
  509. _rv = MCMovieChanged(_self->ob_itself,
  510. m);
  511. _res = Py_BuildValue("l",
  512. _rv);
  513. return _res;
  514. }
  515. static PyObject *MovieCtlObj_MCSetDuration(MovieControllerObject *_self, PyObject *_args)
  516. {
  517. PyObject *_res = NULL;
  518. ComponentResult _rv;
  519. TimeValue duration;
  520. #ifndef MCSetDuration
  521. PyMac_PRECHECK(MCSetDuration);
  522. #endif
  523. if (!PyArg_ParseTuple(_args, "l",
  524. &duration))
  525. return NULL;
  526. _rv = MCSetDuration(_self->ob_itself,
  527. duration);
  528. _res = Py_BuildValue("l",
  529. _rv);
  530. return _res;
  531. }
  532. static PyObject *MovieCtlObj_MCGetCurrentTime(MovieControllerObject *_self, PyObject *_args)
  533. {
  534. PyObject *_res = NULL;
  535. TimeValue _rv;
  536. TimeScale scale;
  537. #ifndef MCGetCurrentTime
  538. PyMac_PRECHECK(MCGetCurrentTime);
  539. #endif
  540. if (!PyArg_ParseTuple(_args, ""))
  541. return NULL;
  542. _rv = MCGetCurrentTime(_self->ob_itself,
  543. &scale);
  544. _res = Py_BuildValue("ll",
  545. _rv,
  546. scale);
  547. return _res;
  548. }
  549. static PyObject *MovieCtlObj_MCNewAttachedController(MovieControllerObject *_self, PyObject *_args)
  550. {
  551. PyObject *_res = NULL;
  552. ComponentResult _rv;
  553. Movie theMovie;
  554. WindowPtr w;
  555. Point where;
  556. #ifndef MCNewAttachedController
  557. PyMac_PRECHECK(MCNewAttachedController);
  558. #endif
  559. if (!PyArg_ParseTuple(_args, "O&O&O&",
  560. MovieObj_Convert, &theMovie,
  561. WinObj_Convert, &w,
  562. PyMac_GetPoint, &where))
  563. return NULL;
  564. _rv = MCNewAttachedController(_self->ob_itself,
  565. theMovie,
  566. w,
  567. where);
  568. _res = Py_BuildValue("l",
  569. _rv);
  570. return _res;
  571. }
  572. static PyObject *MovieCtlObj_MCDraw(MovieControllerObject *_self, PyObject *_args)
  573. {
  574. PyObject *_res = NULL;
  575. ComponentResult _rv;
  576. WindowPtr w;
  577. #ifndef MCDraw
  578. PyMac_PRECHECK(MCDraw);
  579. #endif
  580. if (!PyArg_ParseTuple(_args, "O&",
  581. WinObj_Convert, &w))
  582. return NULL;
  583. _rv = MCDraw(_self->ob_itself,
  584. w);
  585. _res = Py_BuildValue("l",
  586. _rv);
  587. return _res;
  588. }
  589. static PyObject *MovieCtlObj_MCActivate(MovieControllerObject *_self, PyObject *_args)
  590. {
  591. PyObject *_res = NULL;
  592. ComponentResult _rv;
  593. WindowPtr w;
  594. Boolean activate;
  595. #ifndef MCActivate
  596. PyMac_PRECHECK(MCActivate);
  597. #endif
  598. if (!PyArg_ParseTuple(_args, "O&b",
  599. WinObj_Convert, &w,
  600. &activate))
  601. return NULL;
  602. _rv = MCActivate(_self->ob_itself,
  603. w,
  604. activate);
  605. _res = Py_BuildValue("l",
  606. _rv);
  607. return _res;
  608. }
  609. static PyObject *MovieCtlObj_MCIdle(MovieControllerObject *_self, PyObject *_args)
  610. {
  611. PyObject *_res = NULL;
  612. ComponentResult _rv;
  613. #ifndef MCIdle
  614. PyMac_PRECHECK(MCIdle);
  615. #endif
  616. if (!PyArg_ParseTuple(_args, ""))
  617. return NULL;
  618. _rv = MCIdle(_self->ob_itself);
  619. _res = Py_BuildValue("l",
  620. _rv);
  621. return _res;
  622. }
  623. static PyObject *MovieCtlObj_MCKey(MovieControllerObject *_self, PyObject *_args)
  624. {
  625. PyObject *_res = NULL;
  626. ComponentResult _rv;
  627. SInt8 key;
  628. long modifiers;
  629. #ifndef MCKey
  630. PyMac_PRECHECK(MCKey);
  631. #endif
  632. if (!PyArg_ParseTuple(_args, "bl",
  633. &key,
  634. &modifiers))
  635. return NULL;
  636. _rv = MCKey(_self->ob_itself,
  637. key,
  638. modifiers);
  639. _res = Py_BuildValue("l",
  640. _rv);
  641. return _res;
  642. }
  643. static PyObject *MovieCtlObj_MCClick(MovieControllerObject *_self, PyObject *_args)
  644. {
  645. PyObject *_res = NULL;
  646. ComponentResult _rv;
  647. WindowPtr w;
  648. Point where;
  649. long when;
  650. long modifiers;
  651. #ifndef MCClick
  652. PyMac_PRECHECK(MCClick);
  653. #endif
  654. if (!PyArg_ParseTuple(_args, "O&O&ll",
  655. WinObj_Convert, &w,
  656. PyMac_GetPoint, &where,
  657. &when,
  658. &modifiers))
  659. return NULL;
  660. _rv = MCClick(_self->ob_itself,
  661. w,
  662. where,
  663. when,
  664. modifiers);
  665. _res = Py_BuildValue("l",
  666. _rv);
  667. return _res;
  668. }
  669. static PyObject *MovieCtlObj_MCEnableEditing(MovieControllerObject *_self, PyObject *_args)
  670. {
  671. PyObject *_res = NULL;
  672. ComponentResult _rv;
  673. Boolean enabled;
  674. #ifndef MCEnableEditing
  675. PyMac_PRECHECK(MCEnableEditing);
  676. #endif
  677. if (!PyArg_ParseTuple(_args, "b",
  678. &enabled))
  679. return NULL;
  680. _rv = MCEnableEditing(_self->ob_itself,
  681. enabled);
  682. _res = Py_BuildValue("l",
  683. _rv);
  684. return _res;
  685. }
  686. static PyObject *MovieCtlObj_MCIsEditingEnabled(MovieControllerObject *_self, PyObject *_args)
  687. {
  688. PyObject *_res = NULL;
  689. long _rv;
  690. #ifndef MCIsEditingEnabled
  691. PyMac_PRECHECK(MCIsEditingEnabled);
  692. #endif
  693. if (!PyArg_ParseTuple(_args, ""))
  694. return NULL;
  695. _rv = MCIsEditingEnabled(_self->ob_itself);
  696. _res = Py_BuildValue("l",
  697. _rv);
  698. return _res;
  699. }
  700. static PyObject *MovieCtlObj_MCCopy(MovieControllerObject *_self, PyObject *_args)
  701. {
  702. PyObject *_res = NULL;
  703. Movie _rv;
  704. #ifndef MCCopy
  705. PyMac_PRECHECK(MCCopy);
  706. #endif
  707. if (!PyArg_ParseTuple(_args, ""))
  708. return NULL;
  709. _rv = MCCopy(_self->ob_itself);
  710. _res = Py_BuildValue("O&",
  711. MovieObj_New, _rv);
  712. return _res;
  713. }
  714. static PyObject *MovieCtlObj_MCCut(MovieControllerObject *_self, PyObject *_args)
  715. {
  716. PyObject *_res = NULL;
  717. Movie _rv;
  718. #ifndef MCCut
  719. PyMac_PRECHECK(MCCut);
  720. #endif
  721. if (!PyArg_ParseTuple(_args, ""))
  722. return NULL;
  723. _rv = MCCut(_self->ob_itself);
  724. _res = Py_BuildValue("O&",
  725. MovieObj_New, _rv);
  726. return _res;
  727. }
  728. static PyObject *MovieCtlObj_MCPaste(MovieControllerObject *_self, PyObject *_args)
  729. {
  730. PyObject *_res = NULL;
  731. ComponentResult _rv;
  732. Movie srcMovie;
  733. #ifndef MCPaste
  734. PyMac_PRECHECK(MCPaste);
  735. #endif
  736. if (!PyArg_ParseTuple(_args, "O&",
  737. MovieObj_Convert, &srcMovie))
  738. return NULL;
  739. _rv = MCPaste(_self->ob_itself,
  740. srcMovie);
  741. _res = Py_BuildValue("l",
  742. _rv);
  743. return _res;
  744. }
  745. static PyObject *MovieCtlObj_MCClear(MovieControllerObject *_self, PyObject *_args)
  746. {
  747. PyObject *_res = NULL;
  748. ComponentResult _rv;
  749. #ifndef MCClear
  750. PyMac_PRECHECK(MCClear);
  751. #endif
  752. if (!PyArg_ParseTuple(_args, ""))
  753. return NULL;
  754. _rv = MCClear(_self->ob_itself);
  755. _res = Py_BuildValue("l",
  756. _rv);
  757. return _res;
  758. }
  759. static PyObject *MovieCtlObj_MCUndo(MovieControllerObject *_self, PyObject *_args)
  760. {
  761. PyObject *_res = NULL;
  762. ComponentResult _rv;
  763. #ifndef MCUndo
  764. PyMac_PRECHECK(MCUndo);
  765. #endif
  766. if (!PyArg_ParseTuple(_args, ""))
  767. return NULL;
  768. _rv = MCUndo(_self->ob_itself);
  769. _res = Py_BuildValue("l",
  770. _rv);
  771. return _res;
  772. }
  773. static PyObject *MovieCtlObj_MCPositionController(MovieControllerObject *_self, PyObject *_args)
  774. {
  775. PyObject *_res = NULL;
  776. ComponentResult _rv;
  777. Rect movieRect;
  778. Rect controllerRect;
  779. long someFlags;
  780. #ifndef MCPositionController
  781. PyMac_PRECHECK(MCPositionController);
  782. #endif
  783. if (!PyArg_ParseTuple(_args, "O&O&l",
  784. PyMac_GetRect, &movieRect,
  785. PyMac_GetRect, &controllerRect,
  786. &someFlags))
  787. return NULL;
  788. _rv = MCPositionController(_self->ob_itself,
  789. &movieRect,
  790. &controllerRect,
  791. someFlags);
  792. _res = Py_BuildValue("l",
  793. _rv);
  794. return _res;
  795. }
  796. static PyObject *MovieCtlObj_MCGetControllerInfo(MovieControllerObject *_self, PyObject *_args)
  797. {
  798. PyObject *_res = NULL;
  799. ComponentResult _rv;
  800. long someFlags;
  801. #ifndef MCGetControllerInfo
  802. PyMac_PRECHECK(MCGetControllerInfo);
  803. #endif
  804. if (!PyArg_ParseTuple(_args, ""))
  805. return NULL;
  806. _rv = MCGetControllerInfo(_self->ob_itself,
  807. &someFlags);
  808. _res = Py_BuildValue("ll",
  809. _rv,
  810. someFlags);
  811. return _res;
  812. }
  813. static PyObject *MovieCtlObj_MCSetClip(MovieControllerObject *_self, PyObject *_args)
  814. {
  815. PyObject *_res = NULL;
  816. ComponentResult _rv;
  817. RgnHandle theClip;
  818. RgnHandle movieClip;
  819. #ifndef MCSetClip
  820. PyMac_PRECHECK(MCSetClip);
  821. #endif
  822. if (!PyArg_ParseTuple(_args, "O&O&",
  823. ResObj_Convert, &theClip,
  824. ResObj_Convert, &movieClip))
  825. return NULL;
  826. _rv = MCSetClip(_self->ob_itself,
  827. theClip,
  828. movieClip);
  829. _res = Py_BuildValue("l",
  830. _rv);
  831. return _res;
  832. }
  833. static PyObject *MovieCtlObj_MCGetClip(MovieControllerObject *_self, PyObject *_args)
  834. {
  835. PyObject *_res = NULL;
  836. ComponentResult _rv;
  837. RgnHandle theClip;
  838. RgnHandle movieClip;
  839. #ifndef MCGetClip
  840. PyMac_PRECHECK(MCGetClip);
  841. #endif
  842. if (!PyArg_ParseTuple(_args, ""))
  843. return NULL;
  844. _rv = MCGetClip(_self->ob_itself,
  845. &theClip,
  846. &movieClip);
  847. _res = Py_BuildValue("lO&O&",
  848. _rv,
  849. ResObj_New, theClip,
  850. ResObj_New, movieClip);
  851. return _res;
  852. }
  853. static PyObject *MovieCtlObj_MCDrawBadge(MovieControllerObject *_self, PyObject *_args)
  854. {
  855. PyObject *_res = NULL;
  856. ComponentResult _rv;
  857. RgnHandle movieRgn;
  858. RgnHandle badgeRgn;
  859. #ifndef MCDrawBadge
  860. PyMac_PRECHECK(MCDrawBadge);
  861. #endif
  862. if (!PyArg_ParseTuple(_args, "O&",
  863. ResObj_Convert, &movieRgn))
  864. return NULL;
  865. _rv = MCDrawBadge(_self->ob_itself,
  866. movieRgn,
  867. &badgeRgn);
  868. _res = Py_BuildValue("lO&",
  869. _rv,
  870. ResObj_New, badgeRgn);
  871. return _res;
  872. }
  873. static PyObject *MovieCtlObj_MCSetUpEditMenu(MovieControllerObject *_self, PyObject *_args)
  874. {
  875. PyObject *_res = NULL;
  876. ComponentResult _rv;
  877. long modifiers;
  878. MenuHandle mh;
  879. #ifndef MCSetUpEditMenu
  880. PyMac_PRECHECK(MCSetUpEditMenu);
  881. #endif
  882. if (!PyArg_ParseTuple(_args, "lO&",
  883. &modifiers,
  884. MenuObj_Convert, &mh))
  885. return NULL;
  886. _rv = MCSetUpEditMenu(_self->ob_itself,
  887. modifiers,
  888. mh);
  889. _res = Py_BuildValue("l",
  890. _rv);
  891. return _res;
  892. }
  893. static PyObject *MovieCtlObj_MCGetMenuString(MovieControllerObject *_self, PyObject *_args)
  894. {
  895. PyObject *_res = NULL;
  896. ComponentResult _rv;
  897. long modifiers;
  898. short item;
  899. Str255 aString;
  900. #ifndef MCGetMenuString
  901. PyMac_PRECHECK(MCGetMenuString);
  902. #endif
  903. if (!PyArg_ParseTuple(_args, "lhO&",
  904. &modifiers,
  905. &item,
  906. PyMac_GetStr255, aString))
  907. return NULL;
  908. _rv = MCGetMenuString(_self->ob_itself,
  909. modifiers,
  910. item,
  911. aString);
  912. _res = Py_BuildValue("l",
  913. _rv);
  914. return _res;
  915. }
  916. static PyObject *MovieCtlObj_MCPtInController(MovieControllerObject *_self, PyObject *_args)
  917. {
  918. PyObject *_res = NULL;
  919. ComponentResult _rv;
  920. Point thePt;
  921. Boolean inController;
  922. #ifndef MCPtInController
  923. PyMac_PRECHECK(MCPtInController);
  924. #endif
  925. if (!PyArg_ParseTuple(_args, "O&",
  926. PyMac_GetPoint, &thePt))
  927. return NULL;
  928. _rv = MCPtInController(_self->ob_itself,
  929. thePt,
  930. &inController);
  931. _res = Py_BuildValue("lb",
  932. _rv,
  933. inController);
  934. return _res;
  935. }
  936. static PyObject *MovieCtlObj_MCInvalidate(MovieControllerObject *_self, PyObject *_args)
  937. {
  938. PyObject *_res = NULL;
  939. ComponentResult _rv;
  940. WindowPtr w;
  941. RgnHandle invalidRgn;
  942. #ifndef MCInvalidate
  943. PyMac_PRECHECK(MCInvalidate);
  944. #endif
  945. if (!PyArg_ParseTuple(_args, "O&O&",
  946. WinObj_Convert, &w,
  947. ResObj_Convert, &invalidRgn))
  948. return NULL;
  949. _rv = MCInvalidate(_self->ob_itself,
  950. w,
  951. invalidRgn);
  952. _res = Py_BuildValue("l",
  953. _rv);
  954. return _res;
  955. }
  956. static PyObject *MovieCtlObj_MCAdjustCursor(MovieControllerObject *_self, PyObject *_args)
  957. {
  958. PyObject *_res = NULL;
  959. ComponentResult _rv;
  960. WindowPtr w;
  961. Point where;
  962. long modifiers;
  963. #ifndef MCAdjustCursor
  964. PyMac_PRECHECK(MCAdjustCursor);
  965. #endif
  966. if (!PyArg_ParseTuple(_args, "O&O&l",
  967. WinObj_Convert, &w,
  968. PyMac_GetPoint, &where,
  969. &modifiers))
  970. return NULL;
  971. _rv = MCAdjustCursor(_self->ob_itself,
  972. w,
  973. where,
  974. modifiers);
  975. _res = Py_BuildValue("l",
  976. _rv);
  977. return _res;
  978. }
  979. static PyObject *MovieCtlObj_MCGetInterfaceElement(MovieControllerObject *_self, PyObject *_args)
  980. {
  981. PyObject *_res = NULL;
  982. ComponentResult _rv;
  983. MCInterfaceElement whichElement;
  984. void * element;
  985. #ifndef MCGetInterfaceElement
  986. PyMac_PRECHECK(MCGetInterfaceElement);
  987. #endif
  988. if (!PyArg_ParseTuple(_args, "ls",
  989. &whichElement,
  990. &element))
  991. return NULL;
  992. _rv = MCGetInterfaceElement(_self->ob_itself,
  993. whichElement,
  994. element);
  995. _res = Py_BuildValue("l",
  996. _rv);
  997. return _res;
  998. }
  999. static PyObject *MovieCtlObj_MCAddMovieSegment(MovieControllerObject *_self, PyObject *_args)
  1000. {
  1001. PyObject *_res = NULL;
  1002. ComponentResult _rv;
  1003. Movie srcMovie;
  1004. Boolean scaled;
  1005. #ifndef MCAddMovieSegment
  1006. PyMac_PRECHECK(MCAddMovieSegment);
  1007. #endif
  1008. if (!PyArg_ParseTuple(_args, "O&b",
  1009. MovieObj_Convert, &srcMovie,
  1010. &scaled))
  1011. return NULL;
  1012. _rv = MCAddMovieSegment(_self->ob_itself,
  1013. srcMovie,
  1014. scaled);
  1015. _res = Py_BuildValue("l",
  1016. _rv);
  1017. return _res;
  1018. }
  1019. static PyObject *MovieCtlObj_MCTrimMovieSegment(MovieControllerObject *_self, PyObject *_args)
  1020. {
  1021. PyObject *_res = NULL;
  1022. ComponentResult _rv;
  1023. #ifndef MCTrimMovieSegment
  1024. PyMac_PRECHECK(MCTrimMovieSegment);
  1025. #endif
  1026. if (!PyArg_ParseTuple(_args, ""))
  1027. return NULL;
  1028. _rv = MCTrimMovieSegment(_self->ob_itself);
  1029. _res = Py_BuildValue("l",
  1030. _rv);
  1031. return _res;
  1032. }
  1033. static PyObject *MovieCtlObj_MCSetIdleManager(MovieControllerObject *_self, PyObject *_args)
  1034. {
  1035. PyObject *_res = NULL;
  1036. ComponentResult _rv;
  1037. IdleManager im;
  1038. #ifndef MCSetIdleManager
  1039. PyMac_PRECHECK(MCSetIdleManager);
  1040. #endif
  1041. if (!PyArg_ParseTuple(_args, "O&",
  1042. IdleManagerObj_Convert, &im))
  1043. return NULL;
  1044. _rv = MCSetIdleManager(_self->ob_itself,
  1045. im);
  1046. _res = Py_BuildValue("l",
  1047. _rv);
  1048. return _res;
  1049. }
  1050. static PyObject *MovieCtlObj_MCSetControllerCapabilities(MovieControllerObject *_self, PyObject *_args)
  1051. {
  1052. PyObject *_res = NULL;
  1053. ComponentResult _rv;
  1054. long flags;
  1055. long flagsMask;
  1056. #ifndef MCSetControllerCapabilities
  1057. PyMac_PRECHECK(MCSetControllerCapabilities);
  1058. #endif
  1059. if (!PyArg_ParseTuple(_args, "ll",
  1060. &flags,
  1061. &flagsMask))
  1062. return NULL;
  1063. _rv = MCSetControllerCapabilities(_self->ob_itself,
  1064. flags,
  1065. flagsMask);
  1066. _res = Py_BuildValue("l",
  1067. _rv);
  1068. return _res;
  1069. }
  1070. static PyMethodDef MovieCtlObj_methods[] = {
  1071. {"MCSetMovie", (PyCFunction)MovieCtlObj_MCSetMovie, 1,
  1072. PyDoc_STR("(Movie theMovie, WindowPtr movieWindow, Point where) -> (ComponentResult _rv)")},
  1073. {"MCGetIndMovie", (PyCFunction)MovieCtlObj_MCGetIndMovie, 1,
  1074. PyDoc_STR("(short index) -> (Movie _rv)")},
  1075. {"MCRemoveAllMovies", (PyCFunction)MovieCtlObj_MCRemoveAllMovies, 1,
  1076. PyDoc_STR("() -> (ComponentResult _rv)")},
  1077. {"MCRemoveAMovie", (PyCFunction)MovieCtlObj_MCRemoveAMovie, 1,
  1078. PyDoc_STR("(Movie m) -> (ComponentResult _rv)")},
  1079. {"MCRemoveMovie", (PyCFunction)MovieCtlObj_MCRemoveMovie, 1,
  1080. PyDoc_STR("() -> (ComponentResult _rv)")},
  1081. {"MCIsPlayerEvent", (PyCFunction)MovieCtlObj_MCIsPlayerEvent, 1,
  1082. PyDoc_STR("(EventRecord e) -> (ComponentResult _rv)")},
  1083. {"MCDoAction", (PyCFunction)MovieCtlObj_MCDoAction, 1,
  1084. PyDoc_STR("(short action, void * params) -> (ComponentResult _rv)")},
  1085. {"MCSetControllerAttached", (PyCFunction)MovieCtlObj_MCSetControllerAttached, 1,
  1086. PyDoc_STR("(Boolean attach) -> (ComponentResult _rv)")},
  1087. {"MCIsControllerAttached", (PyCFunction)MovieCtlObj_MCIsControllerAttached, 1,
  1088. PyDoc_STR("() -> (ComponentResult _rv)")},
  1089. {"MCSetControllerPort", (PyCFunction)MovieCtlObj_MCSetControllerPort, 1,
  1090. PyDoc_STR("(CGrafPtr gp) -> (ComponentResult _rv)")},
  1091. {"MCGetControllerPort", (PyCFunction)MovieCtlObj_MCGetControllerPort, 1,
  1092. PyDoc_STR("() -> (CGrafPtr _rv)")},
  1093. {"MCSetVisible", (PyCFunction)MovieCtlObj_MCSetVisible, 1,
  1094. PyDoc_STR("(Boolean visible) -> (ComponentResult _rv)")},
  1095. {"MCGetVisible", (PyCFunction)MovieCtlObj_MCGetVisible, 1,
  1096. PyDoc_STR("() -> (ComponentResult _rv)")},
  1097. {"MCGetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRect, 1,
  1098. PyDoc_STR("() -> (ComponentResult _rv, Rect bounds)")},
  1099. {"MCSetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCSetControllerBoundsRect, 1,
  1100. PyDoc_STR("(Rect bounds) -> (ComponentResult _rv)")},
  1101. {"MCGetControllerBoundsRgn", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRgn, 1,
  1102. PyDoc_STR("() -> (RgnHandle _rv)")},
  1103. {"MCGetWindowRgn", (PyCFunction)MovieCtlObj_MCGetWindowRgn, 1,
  1104. PyDoc_STR("(WindowPtr w) -> (RgnHandle _rv)")},
  1105. {"MCMovieChanged", (PyCFunction)MovieCtlObj_MCMovieChanged, 1,
  1106. PyDoc_STR("(Movie m) -> (ComponentResult _rv)")},
  1107. {"MCSetDuration", (PyCFunction)MovieCtlObj_MCSetDuration, 1,
  1108. PyDoc_STR("(TimeValue duration) -> (ComponentResult _rv)")},
  1109. {"MCGetCurrentTime", (PyCFunction)MovieCtlObj_MCGetCurrentTime, 1,
  1110. PyDoc_STR("() -> (TimeValue _rv, TimeScale scale)")},
  1111. {"MCNewAttachedController", (PyCFunction)MovieCtlObj_MCNewAttachedController, 1,
  1112. PyDoc_STR("(Movie theMovie, WindowPtr w, Point where) -> (ComponentResult _rv)")},
  1113. {"MCDraw", (PyCFunction)MovieCtlObj_MCDraw, 1,
  1114. PyDoc_STR("(WindowPtr w) -> (ComponentResult _rv)")},
  1115. {"MCActivate", (PyCFunction)MovieCtlObj_MCActivate, 1,
  1116. PyDoc_STR("(WindowPtr w, Boolean activate) -> (ComponentResult _rv)")},
  1117. {"MCIdle", (PyCFunction)MovieCtlObj_MCIdle, 1,
  1118. PyDoc_STR("() -> (ComponentResult _rv)")},
  1119. {"MCKey", (PyCFunction)MovieCtlObj_MCKey, 1,
  1120. PyDoc_STR("(SInt8 key, long modifiers) -> (ComponentResult _rv)")},
  1121. {"MCClick", (PyCFunction)MovieCtlObj_MCClick, 1,
  1122. PyDoc_STR("(WindowPtr w, Point where, long when, long modifiers) -> (ComponentResult _rv)")},
  1123. {"MCEnableEditing", (PyCFunction)MovieCtlObj_MCEnableEditing, 1,
  1124. PyDoc_STR("(Boolean enabled) -> (ComponentResult _rv)")},
  1125. {"MCIsEditingEnabled", (PyCFunction)MovieCtlObj_MCIsEditingEnabled, 1,
  1126. PyDoc_STR("() -> (long _rv)")},
  1127. {"MCCopy", (PyCFunction)MovieCtlObj_MCCopy, 1,
  1128. PyDoc_STR("() -> (Movie _rv)")},
  1129. {"MCCut", (PyCFunction)MovieCtlObj_MCCut, 1,
  1130. PyDoc_STR("() -> (Movie _rv)")},
  1131. {"MCPaste", (PyCFunction)MovieCtlObj_MCPaste, 1,
  1132. PyDoc_STR("(Movie srcMovie) -> (ComponentResult _rv)")},
  1133. {"MCClear", (PyCFunction)MovieCtlObj_MCClear, 1,
  1134. PyDoc_STR("() -> (ComponentResult _rv)")},
  1135. {"MCUndo", (PyCFunction)MovieCtlObj_MCUndo, 1,
  1136. PyDoc_STR("() -> (ComponentResult _rv)")},
  1137. {"MCPositionController", (PyCFunction)MovieCtlObj_MCPositionController, 1,
  1138. PyDoc_STR("(Rect movieRect, Rect controllerRect, long someFlags) -> (ComponentResult _rv)")},
  1139. {"MCGetControllerInfo", (PyCFunction)MovieCtlObj_MCGetControllerInfo, 1,
  1140. PyDoc_STR("() -> (ComponentResult _rv, long someFlags)")},
  1141. {"MCSetClip", (PyCFunction)MovieCtlObj_MCSetClip, 1,
  1142. PyDoc_STR("(RgnHandle theClip, RgnHandle movieClip) -> (ComponentResult _rv)")},
  1143. {"MCGetClip", (PyCFunction)MovieCtlObj_MCGetClip, 1,
  1144. PyDoc_STR("() -> (ComponentResult _rv, RgnHandle theClip, RgnHandle movieClip)")},
  1145. {"MCDrawBadge", (PyCFunction)MovieCtlObj_MCDrawBadge, 1,
  1146. PyDoc_STR("(RgnHandle movieRgn) -> (ComponentResult _rv, RgnHandle badgeRgn)")},
  1147. {"MCSetUpEditMenu", (PyCFunction)MovieCtlObj_MCSetUpEditMenu, 1,
  1148. PyDoc_STR("(long modifiers, MenuHandle mh) -> (ComponentResult _rv)")},
  1149. {"MCGetMenuString", (PyCFunction)MovieCtlObj_MCGetMenuString, 1,
  1150. PyDoc_STR("(long modifiers, short item, Str255 aString) -> (ComponentResult _rv)")},
  1151. {"MCPtInController", (PyCFunction)MovieCtlObj_MCPtInController, 1,
  1152. PyDoc_STR("(Point thePt) -> (ComponentResult _rv, Boolean inController)")},
  1153. {"MCInvalidate", (PyCFunction)MovieCtlObj_MCInvalidate, 1,
  1154. PyDoc_STR("(WindowPtr w, RgnHandle invalidRgn) -> (ComponentResult _rv)")},
  1155. {"MCAdjustCursor", (PyCFunction)MovieCtlObj_MCAdjustCursor, 1,
  1156. PyDoc_STR("(WindowPtr w, Point where, long modifiers) -> (ComponentResult _rv)")},
  1157. {"MCGetInterfaceElement", (PyCFunction)MovieCtlObj_MCGetInterfaceElement, 1,
  1158. PyDoc_STR("(MCInterfaceElement whichElement, void * element) -> (ComponentResult _rv)")},
  1159. {"MCAddMovieSegment", (PyCFunction)MovieCtlObj_MCAddMovieSegment, 1,
  1160. PyDoc_STR("(Movie srcMovie, Boolean scaled) -> (ComponentResult _rv)")},
  1161. {"MCTrimMovieSegment", (PyCFunction)MovieCtlObj_MCTrimMovieSegment, 1,
  1162. PyDoc_STR("() -> (ComponentResult _rv)")},
  1163. {"MCSetIdleManager", (PyCFunction)MovieCtlObj_MCSetIdleManager, 1,
  1164. PyDoc_STR("(IdleManager im) -> (ComponentResult _rv)")},
  1165. {"MCSetControllerCapabilities", (PyCFunction)MovieCtlObj_MCSetControllerCapabilities, 1,
  1166. PyDoc_STR("(long flags, long flagsMask) -> (ComponentResult _rv)")},
  1167. {NULL, NULL, 0}
  1168. };
  1169. #define MovieCtlObj_getsetlist NULL
  1170. #define MovieCtlObj_compare NULL
  1171. #define MovieCtlObj_repr NULL
  1172. #define MovieCtlObj_hash NULL
  1173. #define MovieCtlObj_tp_init 0
  1174. #define MovieCtlObj_tp_alloc PyType_GenericAlloc
  1175. static PyObject *MovieCtlObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
  1176. {
  1177. PyObject *_self;
  1178. MovieController itself;
  1179. char *kw[] = {"itself", 0};
  1180. if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, MovieCtlObj_Convert, &itself)) return NULL;
  1181. if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
  1182. ((MovieControllerObject *)_self)->ob_itself = itself;
  1183. return _self;
  1184. }
  1185. #define MovieCtlObj_tp_free PyObject_Del
  1186. PyTypeObject MovieController_Type = {
  1187. PyObject_HEAD_INIT(NULL)
  1188. 0, /*ob_size*/
  1189. "_Qt.MovieController", /*tp_name*/
  1190. sizeof(MovieControllerObject), /*tp_basicsize*/
  1191. 0, /*tp_itemsize*/
  1192. /* methods */
  1193. (destructor) MovieCtlObj_dealloc, /*tp_dealloc*/
  1194. 0, /*tp_print*/
  1195. (getattrfunc)0, /*tp_getattr*/
  1196. (setattrfunc)0, /*tp_setattr*/
  1197. (cmpfunc) MovieCtlObj_compare, /*tp_compare*/
  1198. (reprfunc) MovieCtlObj_repr, /*tp_repr*/
  1199. (PyNumberMethods *)0, /* tp_as_number */
  1200. (PySequenceMethods *)0, /* tp_as_sequence */
  1201. (PyMappingMethods *)0, /* tp_as_mapping */
  1202. (hashfunc) MovieCtlObj_hash, /*tp_hash*/
  1203. 0, /*tp_call*/
  1204. 0, /*tp_str*/
  1205. PyObject_GenericGetAttr, /*tp_getattro*/
  1206. PyObject_GenericSetAttr, /*tp_setattro */
  1207. 0, /*tp_as_buffer*/
  1208. Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
  1209. 0, /*tp_doc*/
  1210. 0, /*tp_traverse*/
  1211. 0, /*tp_clear*/
  1212. 0, /*tp_richcompare*/
  1213. 0, /*tp_weaklistoffset*/
  1214. 0, /*tp_iter*/
  1215. 0, /*tp_iternext*/
  1216. MovieCtlObj_methods, /* tp_methods */
  1217. 0, /*tp_members*/
  1218. MovieCtlObj_getsetlist, /*tp_getset*/
  1219. 0, /*tp_base*/
  1220. 0, /*tp_dict*/
  1221. 0, /*tp_descr_get*/
  1222. 0, /*tp_descr_set*/
  1223. 0, /*tp_dictoffset*/
  1224. MovieCtlObj_tp_init, /* tp_init */
  1225. MovieCtlObj_tp_alloc, /* tp_alloc */
  1226. MovieCtlObj_tp_new, /* tp_new */
  1227. MovieCtlObj_tp_free, /* tp_free */
  1228. };
  1229. /* ---------------- End object type MovieController ----------------- */
  1230. /* ---------------------- Object type TimeBase ---------------------- */
  1231. PyTypeObject TimeBase_Type;
  1232. #define TimeBaseObj_Check(x) ((x)->ob_type == &TimeBase_Type || PyObject_TypeCheck((x), &TimeBase_Type))
  1233. typedef struct TimeBaseObject {
  1234. PyObject_HEAD
  1235. TimeBase ob_itself;
  1236. } TimeBaseObject;
  1237. PyObject *TimeBaseObj_New(TimeBase itself)
  1238. {
  1239. TimeBaseObject *it;
  1240. if (itself == NULL) {
  1241. PyErr_SetString(Qt_Error,"Cannot create TimeBase from NULL pointer");
  1242. return NULL;
  1243. }
  1244. it = PyObject_NEW(TimeBaseObject, &TimeBase_Type);
  1245. if (it == NULL) return NULL;
  1246. it->ob_itself = itself;
  1247. return (PyObject *)it;
  1248. }
  1249. int TimeBaseObj_Convert(PyObject *v, TimeBase *p_itself)
  1250. {
  1251. if (v == Py_None)
  1252. {
  1253. *p_itself = NULL;
  1254. return 1;
  1255. }
  1256. if (!TimeBaseObj_Check(v))
  1257. {
  1258. PyErr_SetString(PyExc_TypeError, "TimeBase required");
  1259. return 0;
  1260. }
  1261. *p_itself = ((TimeBaseObject *)v)->ob_itself;
  1262. return 1;
  1263. }
  1264. static void TimeBaseObj_dealloc(TimeBaseObject *self)
  1265. {
  1266. /* Cleanup of self->ob_itself goes here */
  1267. self->ob_type->tp_free((PyObject *)self);
  1268. }
  1269. static PyObject *TimeBaseObj_DisposeTimeBase(TimeBaseObject *_self, PyObject *_args)
  1270. {
  1271. PyObject *_res = NULL;
  1272. #ifndef DisposeTimeBase
  1273. PyMac_PRECHECK(DisposeTimeBase);
  1274. #endif
  1275. if (!PyArg_ParseTuple(_args, ""))
  1276. return NULL;
  1277. DisposeTimeBase(_self->ob_itself);
  1278. Py_INCREF(Py_None);
  1279. _res = Py_None;
  1280. return _res;
  1281. }
  1282. static PyObject *TimeBaseObj_GetTimeBaseTime(TimeBaseObject *_self, PyObject *_args)
  1283. {
  1284. PyObject *_res = NULL;
  1285. TimeValue _rv;
  1286. TimeScale s;
  1287. TimeRecord tr;
  1288. #ifndef GetTimeBaseTime
  1289. PyMac_PRECHECK(GetTimeBaseTime);
  1290. #endif
  1291. if (!PyArg_ParseTuple(_args, "l",
  1292. &s))
  1293. return NULL;
  1294. _rv = GetTimeBaseTime(_self->ob_itself,
  1295. s,
  1296. &tr);
  1297. _res = Py_BuildValue("lO&",
  1298. _rv,
  1299. QtTimeRecord_New, &tr);
  1300. return _res;
  1301. }
  1302. static PyObject *TimeBaseObj_SetTimeBaseTime(TimeBaseObject *_self, PyObject *_args)
  1303. {
  1304. PyObject *_res = NULL;
  1305. TimeRecord tr;
  1306. #ifndef SetTimeBaseTime
  1307. PyMac_PRECHECK(SetTimeBaseTime);
  1308. #endif
  1309. if (!PyArg_ParseTuple(_args, "O&",
  1310. QtTimeRecord_Convert, &tr))
  1311. return NULL;
  1312. SetTimeBaseTime(_self->ob_itself,
  1313. &tr);
  1314. Py_INCREF(Py_None);
  1315. _res = Py_None;
  1316. return _res;
  1317. }
  1318. static PyObject *TimeBaseObj_SetTimeBaseValue(TimeBaseObject *_self, PyObject *_args)
  1319. {
  1320. PyObject *_res = NULL;
  1321. TimeValue t;
  1322. TimeScale s;
  1323. #ifndef SetTimeBaseValue
  1324. PyMac_PRECHECK(SetTimeBaseValue);
  1325. #endif
  1326. if (!PyArg_ParseTuple(_args, "ll",
  1327. &t,
  1328. &s))
  1329. return NULL;
  1330. SetTimeBaseValue(_self->ob_itself,
  1331. t,
  1332. s);
  1333. Py_INCREF(Py_None);
  1334. _res = Py_None;
  1335. return _res;
  1336. }
  1337. static PyObject *TimeBaseObj_GetTimeBaseRate(TimeBaseObject *_self, PyObject *_args)
  1338. {
  1339. PyObject *_res = NULL;
  1340. Fixed _rv;
  1341. #ifndef GetTimeBaseRate
  1342. PyMac_PRECHECK(GetTimeBaseRate);
  1343. #endif
  1344. if (!PyArg_ParseTuple(_args, ""))
  1345. return NULL;
  1346. _rv = GetTimeBaseRate(_self->ob_itself);
  1347. _res = Py_BuildValue("O&",
  1348. PyMac_BuildFixed, _rv);
  1349. return _res;
  1350. }
  1351. static PyObject *TimeBaseObj_SetTimeBaseRate(TimeBaseObject *_self, PyObject *_args)
  1352. {
  1353. PyObject *_res = NULL;
  1354. Fixed r;
  1355. #ifndef SetTimeBaseRate
  1356. PyMac_PRECHECK(SetTimeBaseRate);
  1357. #endif
  1358. if (!PyArg_ParseTuple(_args, "O&",
  1359. PyMac_GetFixed, &r))
  1360. return NULL;
  1361. SetTimeBaseRate(_self->ob_itself,
  1362. r);
  1363. Py_INCREF(Py_None);
  1364. _res = Py_None;
  1365. return _res;
  1366. }
  1367. static PyObject *TimeBaseObj_GetTimeBaseStartTime(TimeBaseObject *_self, PyObject *_args)
  1368. {
  1369. PyObject *_res = NULL;
  1370. TimeValue _rv;
  1371. TimeScale s;
  1372. TimeRecord tr;
  1373. #ifndef GetTimeBaseStartTime
  1374. PyMac_PRECHECK(GetTimeBaseStartTime);
  1375. #endif
  1376. if (!PyArg_ParseTuple(_args, "l",
  1377. &s))
  1378. return NULL;
  1379. _rv = GetTimeBaseStartTime(_self->ob_itself,
  1380. s,
  1381. &tr);
  1382. _res = Py_BuildValue("lO&",
  1383. _rv,
  1384. QtTimeRecord_New, &tr);
  1385. return _res;
  1386. }
  1387. static PyObject *TimeBaseObj_SetTimeBaseStartTime(TimeBaseObject *_self, PyObject *_args)
  1388. {
  1389. PyObject *_res = NULL;
  1390. TimeRecord tr;
  1391. #ifndef SetTimeBaseStartTime
  1392. PyMac_PRECHECK(SetTimeBaseStartTime);
  1393. #endif
  1394. if (!PyArg_ParseTuple(_args, "O&",
  1395. QtTimeRecord_Convert, &tr))
  1396. return NULL;
  1397. SetTimeBaseStartTime(_self->ob_itself,
  1398. &tr);
  1399. Py_INCREF(Py_None);
  1400. _res = Py_None;
  1401. return _res;
  1402. }
  1403. static PyObject *TimeBaseObj_GetTimeBaseStopTime(TimeBaseObject *_self, PyObject *_args)
  1404. {
  1405. PyObject *_res = NULL;
  1406. TimeValue _rv;
  1407. TimeScale s;
  1408. TimeRecord tr;
  1409. #ifndef GetTimeBaseStopTime
  1410. PyMac_PRECHECK(GetTimeBaseStopTime);
  1411. #endif
  1412. if (!PyArg_ParseTuple(_args, "l",
  1413. &s))
  1414. return NULL;
  1415. _rv = GetTimeBaseStopTime(_self->ob_itself,
  1416. s,
  1417. &tr);
  1418. _res = Py_BuildValue("lO&",
  1419. _rv,
  1420. QtTimeRecord_New, &tr);
  1421. return _res;
  1422. }
  1423. static PyObject *TimeBaseObj_SetTimeBaseStopTime(TimeBaseObject *_self, PyObject *_args)
  1424. {
  1425. PyObject *_res = NULL;
  1426. TimeRecord tr;
  1427. #ifndef SetTimeBaseStopTime
  1428. PyMac_PRECHECK(SetTimeBaseStopTime);
  1429. #endif
  1430. if (!PyArg_ParseTuple(_args, "O&",
  1431. QtTimeRecord_Convert, &tr))
  1432. return NULL;
  1433. SetTimeBaseStopTime(_self->ob_itself,
  1434. &tr);
  1435. Py_INCREF(Py_None);
  1436. _res = Py_None;
  1437. return _res;
  1438. }
  1439. static PyObject *TimeBaseObj_GetTimeBaseFlags(TimeBaseObject *_self, PyObject *_args)
  1440. {
  1441. PyObject *_res = NULL;
  1442. long _rv;
  1443. #ifndef GetTimeBaseFlags
  1444. PyMac_PRECHECK(GetTimeBaseFlags);
  1445. #endif
  1446. if (!PyArg_ParseTuple(_args, ""))
  1447. return NULL;
  1448. _rv = GetTimeBaseFlags(_self->ob_itself);
  1449. _res = Py_BuildValue("l",
  1450. _rv);
  1451. return _res;
  1452. }
  1453. static PyObject *TimeBaseObj_SetTimeBaseFlags(TimeBaseObject *_self, PyObject *_args)
  1454. {
  1455. PyObject *_res = NULL;
  1456. long timeBaseFlags;
  1457. #ifndef SetTimeBaseFlags
  1458. PyMac_PRECHECK(SetTimeBaseFlags);
  1459. #endif
  1460. if (!PyArg_ParseTuple(_args, "l",
  1461. &timeBaseFlags))
  1462. return NULL;
  1463. SetTimeBaseFlags(_self->ob_itself,
  1464. timeBaseFlags);
  1465. Py_INCREF(Py_None);
  1466. _res = Py_None;
  1467. return _res;
  1468. }
  1469. static PyObject *TimeBaseObj_SetTimeBaseMasterTimeBase(TimeBaseObject *_self, PyObject *_args)
  1470. {
  1471. PyObject *_res = NULL;
  1472. TimeBase master;
  1473. TimeRecord slaveZero;
  1474. #ifndef SetTimeBaseMasterTimeBase
  1475. PyMac_PRECHECK(SetTimeBaseMasterTimeBase);
  1476. #endif
  1477. if (!PyArg_ParseTuple(_args, "O&O&",
  1478. TimeBaseObj_Convert, &master,
  1479. QtTimeRecord_Convert, &slaveZero))
  1480. return NULL;
  1481. SetTimeBaseMasterTimeBase(_self->ob_itself,
  1482. master,
  1483. &slaveZero);
  1484. Py_INCREF(Py_None);
  1485. _res = Py_None;
  1486. return _res;
  1487. }
  1488. static PyObject *TimeBaseObj_GetTimeBaseMasterTimeBase(TimeBaseObject *_self, PyObject *_args)
  1489. {
  1490. PyObject *_res = NULL;
  1491. TimeBase _rv;
  1492. #ifndef GetTimeBaseMasterTimeBase
  1493. PyMac_PRECHECK(GetTimeBaseMasterTimeBase);
  1494. #endif
  1495. if (!PyArg_ParseTuple(_args, ""))
  1496. return NULL;
  1497. _rv = GetTimeBaseMasterTimeBase(_self->ob_itself);
  1498. _res = Py_BuildValue("O&",
  1499. TimeBaseObj_New, _rv);
  1500. return _res;
  1501. }
  1502. static PyObject *TimeBaseObj_SetTimeBaseMasterClock(TimeBaseObject *_self, PyObject *_args)
  1503. {
  1504. PyObject *_res = NULL;
  1505. Component clockMeister;
  1506. TimeRecord slaveZero;
  1507. #ifndef SetTimeBaseMasterClock
  1508. PyMac_PRECHECK(SetTimeBaseMasterClock);
  1509. #endif
  1510. if (!PyArg_ParseTuple(_args, "O&O&",
  1511. CmpObj_Convert, &clockMeister,
  1512. QtTimeRecord_Convert, &slaveZero))
  1513. return NULL;
  1514. SetTimeBaseMasterClock(_self->ob_itself,
  1515. clockMeister,
  1516. &slaveZero);
  1517. Py_INCREF(Py_None);
  1518. _res = Py_None;
  1519. return _res;
  1520. }
  1521. static PyObject *TimeBaseObj_GetTimeBaseMasterClock(TimeBaseObject *_self, PyObject *_args)
  1522. {
  1523. PyObject *_res = NULL;
  1524. ComponentInstance _rv;
  1525. #ifndef GetTimeBaseMasterClock
  1526. PyMac_PRECHECK(GetTimeBaseMasterClock);
  1527. #endif
  1528. if (!PyArg_ParseTuple(_args, ""))
  1529. return NULL;
  1530. _rv = GetTimeBaseMasterClock(_self->ob_itself);
  1531. _res = Py_BuildValue("O&",
  1532. CmpInstObj_New, _rv);
  1533. return _res;
  1534. }
  1535. static PyObject *TimeBaseObj_GetTimeBaseStatus(TimeBaseObject *_self, PyObject *_args)
  1536. {
  1537. PyObject *_res = NULL;
  1538. long _rv;
  1539. TimeRecord unpinnedTime;
  1540. #ifndef GetTimeBaseStatus
  1541. PyMac_PRECHECK(GetTimeBaseStatus);
  1542. #endif
  1543. if (!PyArg_ParseTuple(_args, ""))
  1544. return NULL;
  1545. _rv = GetTimeBaseStatus(_self->ob_itself,
  1546. &unpinnedTime);
  1547. _res = Py_BuildValue("lO&",
  1548. _rv,
  1549. QtTimeRecord_New, &unpinnedTime);
  1550. return _res;
  1551. }
  1552. static PyObject *TimeBaseObj_SetTimeBaseZero(TimeBaseObject *_self, PyObject *_args)
  1553. {
  1554. PyObject *_res = NULL;
  1555. TimeRecord zero;
  1556. #ifndef SetTimeBaseZero
  1557. PyMac_PRECHECK(SetTimeBaseZero);
  1558. #endif
  1559. if (!PyArg_ParseTuple(_args, "O&",
  1560. QtTimeRecord_Convert, &zero))
  1561. return NULL;
  1562. SetTimeBaseZero(_self->ob_itself,
  1563. &zero);
  1564. Py_INCREF(Py_None);
  1565. _res = Py_None;
  1566. return _res;
  1567. }
  1568. static PyObject *TimeBaseObj_GetTimeBaseEffectiveRate(TimeBaseObject *_self, PyObject *_args)
  1569. {
  1570. PyObject *_res = NULL;
  1571. Fixed _rv;
  1572. #ifndef GetTimeBaseEffectiveRate
  1573. PyMac_PRECHECK(GetTimeBaseEffectiveRate);
  1574. #endif
  1575. if (!PyArg_ParseTuple(_args, ""))
  1576. return NULL;
  1577. _rv = GetTimeBaseEffectiveRate(_self->ob_itself);
  1578. _res = Py_BuildValue("O&",
  1579. PyMac_BuildFixed, _rv);
  1580. return _res;
  1581. }
  1582. static PyMethodDef TimeBaseObj_methods[] = {
  1583. {"DisposeTimeBase", (PyCFunction)TimeBaseObj_DisposeTimeBase, 1,
  1584. PyDoc_STR("() -> None")},
  1585. {"GetTimeBaseTime", (PyCFunction)TimeBaseObj_GetTimeBaseTime, 1,
  1586. PyDoc_STR("(TimeScale s) -> (TimeValue _rv, TimeRecord tr)")},
  1587. {"SetTimeBaseTime", (PyCFunction)TimeBaseObj_SetTimeBaseTime, 1,
  1588. PyDoc_STR("(TimeRecord tr) -> None")},
  1589. {"SetTimeBaseValue", (PyCFunction)TimeBaseObj_SetTimeBaseValue, 1,
  1590. PyDoc_STR("(TimeValue t, TimeScale s) -> None")},
  1591. {"GetTimeBaseRate", (PyCFunction)TimeBaseObj_GetTimeBaseRate, 1,
  1592. PyDoc_STR("() -> (Fixed _rv)")},
  1593. {"SetTimeBaseRate", (PyCFunction)TimeBaseObj_SetTimeBaseRate, 1,
  1594. PyDoc_STR("(Fixed r) -> None")},
  1595. {"GetTimeBaseStartTime", (PyCFunction)TimeBaseObj_GetTimeBaseStartTime, 1,
  1596. PyDoc_STR("(TimeScale s) -> (TimeValue _rv, TimeRecord tr)")},
  1597. {"SetTimeBaseStartTime", (PyCFunction)TimeBaseObj_SetTimeBaseStartTime, 1,
  1598. PyDoc_STR("(TimeRecord tr) -> None")},
  1599. {"GetTimeBaseStopTime", (PyCFunction)TimeBaseObj_GetTimeBaseStopTime, 1,
  1600. PyDoc_STR("(TimeScale s) -> (TimeValue _rv, TimeRecord tr)")},
  1601. {"SetTimeBaseStopTime", (PyCFunction)TimeBaseObj_SetTimeBaseStopTime, 1,
  1602. PyDoc_STR("(TimeRecord tr) -> None")},
  1603. {"GetTimeBaseFlags", (PyCFunction)TimeBaseObj_GetTimeBaseFlags, 1,
  1604. PyDoc_STR("() -> (long _rv)")},
  1605. {"SetTimeBaseFlags", (PyCFunction)TimeBaseObj_SetTimeBaseFlags, 1,
  1606. PyDoc_STR("(long timeBaseFlags) -> None")},
  1607. {"SetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_SetTimeBaseMasterTimeBase, 1,
  1608. PyDoc_STR("(TimeBase master, TimeRecord slaveZero) -> None")},
  1609. {"GetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_GetTimeBaseMasterTimeBase, 1,
  1610. PyDoc_STR("() -> (TimeBase _rv)")},
  1611. {"SetTimeBase…