?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added ref to Misc/NEWS file; added hint to run regen script on Linux.
[python/dscho.git] / Mac / Modules / qt / Qtmodule.c
blobffba461dd9aca56e34d63fd3d2556c2a8ffa6516
1
2 /* =========================== Module Qt ============================ */
3
4 #include "Python.h"
5
6
7
8 #define SystemSevenOrLater 1
9
10 #include "macglue.h"
11 #include <Memory.h>
12 #include <Dialogs.h>
13 #include <Menus.h>
14 #include <Controls.h>
15
16 extern PyObject *ResObj_New(Handle);
17 extern int ResObj_Convert(PyObject *, Handle *);
18 extern PyObject *OptResObj_New(Handle);
19 extern int OptResObj_Convert(PyObject *, Handle *);
20
21 extern PyObject *WinObj_New(WindowPtr);
22 extern int WinObj_Convert(PyObject *, WindowPtr *);
23 extern PyTypeObject Window_Type;
24 #define WinObj_Check(x) ((x)->ob_type == &Window_Type)
25
26 extern PyObject *DlgObj_New(DialogPtr);
27 extern int DlgObj_Convert(PyObject *, DialogPtr *);
28 extern PyTypeObject Dialog_Type;
29 #define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
30
31 extern PyObject *MenuObj_New(MenuHandle);
32 extern int MenuObj_Convert(PyObject *, MenuHandle *);
33
34 extern PyObject *CtlObj_New(ControlHandle);
35 extern int CtlObj_Convert(PyObject *, ControlHandle *);
36
37 extern PyObject *GrafObj_New(GrafPtr);
38 extern int GrafObj_Convert(PyObject *, GrafPtr *);
39
40 extern PyObject *BMObj_New(BitMapPtr);
41 extern int BMObj_Convert(PyObject *, BitMapPtr *);
42
43 extern PyObject *WinObj_WhichWindow(WindowPtr);
44
45 #include <Movies.h>
46
47 /* Exported by Cmmodule.c: */
48 extern PyObject *CmpObj_New(Component);
49 extern int CmpObj_Convert(PyObject *, Component *);
50 extern PyObject *CmpInstObj_New(ComponentInstance);
51 extern int CmpInstObj_Convert(PyObject *, ComponentInstance *);
52
53 /* Exported by Qdmodule.c: */
54 extern PyObject *QdRGB_New(RGBColor *);
55 extern int QdRGB_Convert(PyObject *, RGBColor *);
56
57 /* Our own, used before defined: */
58 staticforward PyObject *TrackObj_New(Track);
59 staticforward int TrackObj_Convert(PyObject *, Track *);
60 staticforward PyObject *MovieObj_New(Movie);
61 staticforward int MovieObj_Convert(PyObject *, Movie *);
62 staticforward PyObject *MovieCtlObj_New(MovieController);
63 staticforward int MovieCtlObj_Convert(PyObject *, MovieController *);
64
65
66
67 static PyObject *Qt_Error;
68
69 /* ------------------ Object type MovieController ------------------- */
70
71 PyTypeObject MovieController_Type;
72
73 #define MovieCtlObj_Check(x) ((x)->ob_type == &MovieController_Type)
74
75 typedef struct MovieControllerObject {
76 PyObject_HEAD
77 MovieController ob_itself;
78 } MovieControllerObject;
79
80 PyObject *MovieCtlObj_New(itself)
81 MovieController itself;
82 {
83 MovieControllerObject *it;
84 if (itself == NULL) {
85 PyErr_SetString(Qt_Error,"Cannot create null MovieController");
86 return NULL;
87 }
88 it = PyObject_NEW(MovieControllerObject, &MovieController_Type);
89 if (it == NULL) return NULL;
90 it->ob_itself = itself;
91 return (PyObject *)it;
92 }
93 MovieCtlObj_Convert(v, p_itself)
94 PyObject *v;
95 MovieController *p_itself;
96 {
97 if (!MovieCtlObj_Check(v))
98 {
99 PyErr_SetString(PyExc_TypeError, "MovieController required");
100 return 0;
101 }
102 *p_itself = ((MovieControllerObject *)v)->ob_itself;
103 return 1;
104 }
105
106 static void MovieCtlObj_dealloc(self)
107 MovieControllerObject *self;
108 {
109 DisposeMovieController(self->ob_itself);
110 PyMem_DEL(self);
111 }
112
113 static PyObject *MovieCtlObj_MCSetMovie(_self, _args)
114 MovieControllerObject *_self;
115 PyObject *_args;
116 {
117 PyObject *_res = NULL;
118 ComponentResult _rv;
119 Movie theMovie;
120 WindowPtr movieWindow;
121 Point where;
122 if (!PyArg_ParseTuple(_args, "O&O&O&",
123 MovieObj_Convert, &theMovie,
124 WinObj_Convert, &movieWindow,
125 PyMac_GetPoint, &where))
126 return NULL;
127 _rv = MCSetMovie(_self->ob_itself,
128 theMovie,
129 movieWindow,
130 where);
131 _res = Py_BuildValue("l",
132 _rv);
133 return _res;
134 }
135
136 static PyObject *MovieCtlObj_MCGetIndMovie(_self, _args)
137 MovieControllerObject *_self;
138 PyObject *_args;
139 {
140 PyObject *_res = NULL;
141 Movie _rv;
142 short index;
143 if (!PyArg_ParseTuple(_args, "h",
144 &index))
145 return NULL;
146 _rv = MCGetIndMovie(_self->ob_itself,
147 index);
148 _res = Py_BuildValue("O&",
149 MovieObj_New, _rv);
150 return _res;
151 }
152
153 static PyObject *MovieCtlObj_MCRemoveMovie(_self, _args)
154 MovieControllerObject *_self;
155 PyObject *_args;
156 {
157 PyObject *_res = NULL;
158 ComponentResult _rv;
159 if (!PyArg_ParseTuple(_args, ""))
160 return NULL;
161 _rv = MCRemoveMovie(_self->ob_itself);
162 _res = Py_BuildValue("l",
163 _rv);
164 return _res;
165 }
166
167 static PyObject *MovieCtlObj_MCIsPlayerEvent(_self, _args)
168 MovieControllerObject *_self;
169 PyObject *_args;
170 {
171 PyObject *_res = NULL;
172 ComponentResult _rv;
173 EventRecord e;
174 if (!PyArg_ParseTuple(_args, "O&",
175 PyMac_GetEventRecord, &e))
176 return NULL;
177 _rv = MCIsPlayerEvent(_self->ob_itself,
178 &e);
179 _res = Py_BuildValue("l",
180 _rv);
181 return _res;
182 }
183
184 static PyObject *MovieCtlObj_MCDoAction(_self, _args)
185 MovieControllerObject *_self;
186 PyObject *_args;
187 {
188 PyObject *_res = NULL;
189 ComponentResult _rv;
190 short action;
191 void * params;
192 if (!PyArg_ParseTuple(_args, "hs",
193 &action,
194 &params))
195 return NULL;
196 _rv = MCDoAction(_self->ob_itself,
197 action,
198 params);
199 _res = Py_BuildValue("l",
200 _rv);
201 return _res;
202 }
203
204 static PyObject *MovieCtlObj_MCSetControllerAttached(_self, _args)
205 MovieControllerObject *_self;
206 PyObject *_args;
207 {
208 PyObject *_res = NULL;
209 ComponentResult _rv;
210 Boolean attach;
211 if (!PyArg_ParseTuple(_args, "b",
212 &attach))
213 return NULL;
214 _rv = MCSetControllerAttached(_self->ob_itself,
215 attach);
216 _res = Py_BuildValue("l",
217 _rv);
218 return _res;
219 }
220
221 static PyObject *MovieCtlObj_MCIsControllerAttached(_self, _args)
222 MovieControllerObject *_self;
223 PyObject *_args;
224 {
225 PyObject *_res = NULL;
226 ComponentResult _rv;
227 if (!PyArg_ParseTuple(_args, ""))
228 return NULL;
229 _rv = MCIsControllerAttached(_self->ob_itself);
230 _res = Py_BuildValue("l",
231 _rv);
232 return _res;
233 }
234
235 static PyObject *MovieCtlObj_MCSetVisible(_self, _args)
236 MovieControllerObject *_self;
237 PyObject *_args;
238 {
239 PyObject *_res = NULL;
240 ComponentResult _rv;
241 Boolean visible;
242 if (!PyArg_ParseTuple(_args, "b",
243 &visible))
244 return NULL;
245 _rv = MCSetVisible(_self->ob_itself,
246 visible);
247 _res = Py_BuildValue("l",
248 _rv);
249 return _res;
250 }
251
252 static PyObject *MovieCtlObj_MCGetVisible(_self, _args)
253 MovieControllerObject *_self;
254 PyObject *_args;
255 {
256 PyObject *_res = NULL;
257 ComponentResult _rv;
258 if (!PyArg_ParseTuple(_args, ""))
259 return NULL;
260 _rv = MCGetVisible(_self->ob_itself);
261 _res = Py_BuildValue("l",
262 _rv);
263 return _res;
264 }
265
266 static PyObject *MovieCtlObj_MCGetControllerBoundsRect(_self, _args)
267 MovieControllerObject *_self;
268 PyObject *_args;
269 {
270 PyObject *_res = NULL;
271 ComponentResult _rv;
272 Rect bounds;
273 if (!PyArg_ParseTuple(_args, ""))
274 return NULL;
275 _rv = MCGetControllerBoundsRect(_self->ob_itself,
276 &bounds);
277 _res = Py_BuildValue("lO&",
278 _rv,
279 PyMac_BuildRect, &bounds);
280 return _res;
281 }
282
283 static PyObject *MovieCtlObj_MCSetControllerBoundsRect(_self, _args)
284 MovieControllerObject *_self;
285 PyObject *_args;
286 {
287 PyObject *_res = NULL;
288 ComponentResult _rv;
289 Rect bounds;
290 if (!PyArg_ParseTuple(_args, "O&",
291 PyMac_GetRect, &bounds))
292 return NULL;
293 _rv = MCSetControllerBoundsRect(_self->ob_itself,
294 &bounds);
295 _res = Py_BuildValue("l",
296 _rv);
297 return _res;
298 }
299
300 static PyObject *MovieCtlObj_MCGetControllerBoundsRgn(_self, _args)
301 MovieControllerObject *_self;
302 PyObject *_args;
303 {
304 PyObject *_res = NULL;
305 RgnHandle _rv;
306 if (!PyArg_ParseTuple(_args, ""))
307 return NULL;
308 _rv = MCGetControllerBoundsRgn(_self->ob_itself);
309 _res = Py_BuildValue("O&",
310 ResObj_New, _rv);
311 return _res;
312 }
313
314 static PyObject *MovieCtlObj_MCGetWindowRgn(_self, _args)
315 MovieControllerObject *_self;
316 PyObject *_args;
317 {
318 PyObject *_res = NULL;
319 RgnHandle _rv;
320 WindowPtr w;
321 if (!PyArg_ParseTuple(_args, "O&",
322 WinObj_Convert, &w))
323 return NULL;
324 _rv = MCGetWindowRgn(_self->ob_itself,
325 w);
326 _res = Py_BuildValue("O&",
327 ResObj_New, _rv);
328 return _res;
329 }
330
331 static PyObject *MovieCtlObj_MCMovieChanged(_self, _args)
332 MovieControllerObject *_self;
333 PyObject *_args;
334 {
335 PyObject *_res = NULL;
336 ComponentResult _rv;
337 Movie m;
338 if (!PyArg_ParseTuple(_args, "O&",
339 MovieObj_Convert, &m))
340 return NULL;
341 _rv = MCMovieChanged(_self->ob_itself,
342 m);
343 _res = Py_BuildValue("l",
344 _rv);
345 return _res;
346 }
347
348 static PyObject *MovieCtlObj_MCSetDuration(_self, _args)
349 MovieControllerObject *_self;
350 PyObject *_args;
351 {
352 PyObject *_res = NULL;
353 ComponentResult _rv;
354 TimeValue duration;
355 if (!PyArg_ParseTuple(_args, "l",
356 &duration))
357 return NULL;
358 _rv = MCSetDuration(_self->ob_itself,
359 duration);
360 _res = Py_BuildValue("l",
361 _rv);
362 return _res;
363 }
364
365 static PyObject *MovieCtlObj_MCGetCurrentTime(_self, _args)
366 MovieControllerObject *_self;
367 PyObject *_args;
368 {
369 PyObject *_res = NULL;
370 TimeValue _rv;
371 TimeScale scale;
372 if (!PyArg_ParseTuple(_args, ""))
373 return NULL;
374 _rv = MCGetCurrentTime(_self->ob_itself,
375 &scale);
376 _res = Py_BuildValue("ll",
377 _rv,
378 scale);
379 return _res;
380 }
381
382 static PyObject *MovieCtlObj_MCNewAttachedController(_self, _args)
383 MovieControllerObject *_self;
384 PyObject *_args;
385 {
386 PyObject *_res = NULL;
387 ComponentResult _rv;
388 Movie theMovie;
389 WindowPtr w;
390 Point where;
391 if (!PyArg_ParseTuple(_args, "O&O&O&",
392 MovieObj_Convert, &theMovie,
393 WinObj_Convert, &w,
394 PyMac_GetPoint, &where))
395 return NULL;
396 _rv = MCNewAttachedController(_self->ob_itself,
397 theMovie,
398 w,
399 where);
400 _res = Py_BuildValue("l",
401 _rv);
402 return _res;
403 }
404
405 static PyObject *MovieCtlObj_MCDraw(_self, _args)
406 MovieControllerObject *_self;
407 PyObject *_args;
408 {
409 PyObject *_res = NULL;
410 ComponentResult _rv;
411 WindowPtr w;
412 if (!PyArg_ParseTuple(_args, "O&",
413 WinObj_Convert, &w))
414 return NULL;
415 _rv = MCDraw(_self->ob_itself,
416 w);
417 _res = Py_BuildValue("l",
418 _rv);
419 return _res;
420 }
421
422 static PyObject *MovieCtlObj_MCActivate(_self, _args)
423 MovieControllerObject *_self;
424 PyObject *_args;
425 {
426 PyObject *_res = NULL;
427 ComponentResult _rv;
428 WindowPtr w;
429 Boolean activate;
430 if (!PyArg_ParseTuple(_args, "O&b",
431 WinObj_Convert, &w,
432 &activate))
433 return NULL;
434 _rv = MCActivate(_self->ob_itself,
435 w,
436 activate);
437 _res = Py_BuildValue("l",
438 _rv);
439 return _res;
440 }
441
442 static PyObject *MovieCtlObj_MCIdle(_self, _args)
443 MovieControllerObject *_self;
444 PyObject *_args;
445 {
446 PyObject *_res = NULL;
447 ComponentResult _rv;
448 if (!PyArg_ParseTuple(_args, ""))
449 return NULL;
450 _rv = MCIdle(_self->ob_itself);
451 _res = Py_BuildValue("l",
452 _rv);
453 return _res;
454 }
455
456 static PyObject *MovieCtlObj_MCKey(_self, _args)
457 MovieControllerObject *_self;
458 PyObject *_args;
459 {
460 PyObject *_res = NULL;
461 ComponentResult _rv;
462 SInt8 key;
463 long modifiers;
464 if (!PyArg_ParseTuple(_args, "bl",
465 &key,
466 &modifiers))
467 return NULL;
468 _rv = MCKey(_self->ob_itself,
469 key,
470 modifiers);
471 _res = Py_BuildValue("l",
472 _rv);
473 return _res;
474 }
475
476 static PyObject *MovieCtlObj_MCClick(_self, _args)
477 MovieControllerObject *_self;
478 PyObject *_args;
479 {
480 PyObject *_res = NULL;
481 ComponentResult _rv;
482 WindowPtr w;
483 Point where;
484 long when;
485 long modifiers;
486 if (!PyArg_ParseTuple(_args, "O&O&ll",
487 WinObj_Convert, &w,
488 PyMac_GetPoint, &where,
489 &when,
490 &modifiers))
491 return NULL;
492 _rv = MCClick(_self->ob_itself,
493 w,
494 where,
495 when,
496 modifiers);
497 _res = Py_BuildValue("l",
498 _rv);
499 return _res;
500 }
501
502 static PyObject *MovieCtlObj_MCEnableEditing(_self, _args)
503 MovieControllerObject *_self;
504 PyObject *_args;
505 {
506 PyObject *_res = NULL;
507 ComponentResult _rv;
508 Boolean enabled;
509 if (!PyArg_ParseTuple(_args, "b",
510 &enabled))
511 return NULL;
512 _rv = MCEnableEditing(_self->ob_itself,
513 enabled);
514 _res = Py_BuildValue("l",
515 _rv);
516 return _res;
517 }
518
519 static PyObject *MovieCtlObj_MCIsEditingEnabled(_self, _args)
520 MovieControllerObject *_self;
521 PyObject *_args;
522 {
523 PyObject *_res = NULL;
524 long _rv;
525 if (!PyArg_ParseTuple(_args, ""))
526 return NULL;
527 _rv = MCIsEditingEnabled(_self->ob_itself);
528 _res = Py_BuildValue("l",
529 _rv);
530 return _res;
531 }
532
533 static PyObject *MovieCtlObj_MCCopy(_self, _args)
534 MovieControllerObject *_self;
535 PyObject *_args;
536 {
537 PyObject *_res = NULL;
538 Movie _rv;
539 if (!PyArg_ParseTuple(_args, ""))
540 return NULL;
541 _rv = MCCopy(_self->ob_itself);
542 _res = Py_BuildValue("O&",
543 MovieObj_New, _rv);
544 return _res;
545 }
546
547 static PyObject *MovieCtlObj_MCCut(_self, _args)
548 MovieControllerObject *_self;
549 PyObject *_args;
550 {
551 PyObject *_res = NULL;
552 Movie _rv;
553 if (!PyArg_ParseTuple(_args, ""))
554 return NULL;
555 _rv = MCCut(_self->ob_itself);
556 _res = Py_BuildValue("O&",
557 MovieObj_New, _rv);
558 return _res;
559 }
560
561 static PyObject *MovieCtlObj_MCPaste(_self, _args)
562 MovieControllerObject *_self;
563 PyObject *_args;
564 {
565 PyObject *_res = NULL;
566 ComponentResult _rv;
567 Movie srcMovie;
568 if (!PyArg_ParseTuple(_args, "O&",
569 MovieObj_Convert, &srcMovie))
570 return NULL;
571 _rv = MCPaste(_self->ob_itself,
572 srcMovie);
573 _res = Py_BuildValue("l",
574 _rv);
575 return _res;
576 }
577
578 static PyObject *MovieCtlObj_MCClear(_self, _args)
579 MovieControllerObject *_self;
580 PyObject *_args;
581 {
582 PyObject *_res = NULL;
583 ComponentResult _rv;
584 if (!PyArg_ParseTuple(_args, ""))
585 return NULL;
586 _rv = MCClear(_self->ob_itself);
587 _res = Py_BuildValue("l",
588 _rv);
589 return _res;
590 }
591
592 static PyObject *MovieCtlObj_MCUndo(_self, _args)
593 MovieControllerObject *_self;
594 PyObject *_args;
595 {
596 PyObject *_res = NULL;
597 ComponentResult _rv;
598 if (!PyArg_ParseTuple(_args, ""))
599 return NULL;
600 _rv = MCUndo(_self->ob_itself);
601 _res = Py_BuildValue("l",
602 _rv);
603 return _res;
604 }
605
606 static PyObject *MovieCtlObj_MCPositionController(_self, _args)
607 MovieControllerObject *_self;
608 PyObject *_args;
609 {
610 PyObject *_res = NULL;
611 ComponentResult _rv;
612 Rect movieRect;
613 Rect controllerRect;
614 long someFlags;
615 if (!PyArg_ParseTuple(_args, "O&O&l",
616 PyMac_GetRect, &movieRect,
617 PyMac_GetRect, &controllerRect,
618 &someFlags))
619 return NULL;
620 _rv = MCPositionController(_self->ob_itself,
621 &movieRect,
622 &controllerRect,
623 someFlags);
624 _res = Py_BuildValue("l",
625 _rv);
626 return _res;
627 }
628
629 static PyObject *MovieCtlObj_MCGetControllerInfo(_self, _args)
630 MovieControllerObject *_self;
631 PyObject *_args;
632 {
633 PyObject *_res = NULL;
634 ComponentResult _rv;
635 long someFlags;
636 if (!PyArg_ParseTuple(_args, ""))
637 return NULL;
638 _rv = MCGetControllerInfo(_self->ob_itself,
639 &someFlags);
640 _res = Py_BuildValue("ll",
641 _rv,
642 someFlags);
643 return _res;
644 }
645
646 static PyObject *MovieCtlObj_MCSetClip(_self, _args)
647 MovieControllerObject *_self;
648 PyObject *_args;
649 {
650 PyObject *_res = NULL;
651 ComponentResult _rv;
652 RgnHandle theClip;
653 RgnHandle movieClip;
654 if (!PyArg_ParseTuple(_args, "O&O&",
655 ResObj_Convert, &theClip,
656 ResObj_Convert, &movieClip))
657 return NULL;
658 _rv = MCSetClip(_self->ob_itself,
659 theClip,
660 movieClip);
661 _res = Py_BuildValue("l",
662 _rv);
663 return _res;
664 }
665
666 static PyObject *MovieCtlObj_MCGetClip(_self, _args)
667 MovieControllerObject *_self;
668 PyObject *_args;
669 {
670 PyObject *_res = NULL;
671 ComponentResult _rv;
672 RgnHandle theClip;
673 RgnHandle movieClip;
674 if (!PyArg_ParseTuple(_args, ""))
675 return NULL;
676 _rv = MCGetClip(_self->ob_itself,
677 &theClip,
678 &movieClip);
679 _res = Py_BuildValue("lO&O&",
680 _rv,
681 ResObj_New, theClip,
682 ResObj_New, movieClip);
683 return _res;
684 }
685
686 static PyObject *MovieCtlObj_MCDrawBadge(_self, _args)
687 MovieControllerObject *_self;
688 PyObject *_args;
689 {
690 PyObject *_res = NULL;
691 ComponentResult _rv;
692 RgnHandle movieRgn;
693 RgnHandle badgeRgn;
694 if (!PyArg_ParseTuple(_args, "O&",
695 ResObj_Convert, &movieRgn))
696 return NULL;
697 _rv = MCDrawBadge(_self->ob_itself,
698 movieRgn,
699 &badgeRgn);
700 _res = Py_BuildValue("lO&",
701 _rv,
702 ResObj_New, badgeRgn);
703 return _res;
704 }
705
706 static PyObject *MovieCtlObj_MCSetUpEditMenu(_self, _args)
707 MovieControllerObject *_self;
708 PyObject *_args;
709 {
710 PyObject *_res = NULL;
711 ComponentResult _rv;
712 long modifiers;
713 MenuHandle mh;
714 if (!PyArg_ParseTuple(_args, "lO&",
715 &modifiers,
716 MenuObj_Convert, &mh))
717 return NULL;
718 _rv = MCSetUpEditMenu(_self->ob_itself,
719 modifiers,
720 mh);
721 _res = Py_BuildValue("l",
722 _rv);
723 return _res;
724 }
725
726 static PyObject *MovieCtlObj_MCGetMenuString(_self, _args)
727 MovieControllerObject *_self;
728 PyObject *_args;
729 {
730 PyObject *_res = NULL;
731 ComponentResult _rv;
732 long modifiers;
733 short item;
734 Str255 aString;
735 if (!PyArg_ParseTuple(_args, "lhO&",
736 &modifiers,
737 &item,
738 PyMac_GetStr255, aString))
739 return NULL;
740 _rv = MCGetMenuString(_self->ob_itself,
741 modifiers,
742 item,
743 aString);
744 _res = Py_BuildValue("l",
745 _rv);
746 return _res;
747 }
748
749 static PyMethodDef MovieCtlObj_methods[] = {
750 {"MCSetMovie", (PyCFunction)MovieCtlObj_MCSetMovie, 1,
751 "(Movie theMovie, WindowPtr movieWindow, Point where) -> (ComponentResult _rv)"},
752 {"MCGetIndMovie", (PyCFunction)MovieCtlObj_MCGetIndMovie, 1,
753 "(short index) -> (Movie _rv)"},
754 {"MCRemoveMovie", (PyCFunction)MovieCtlObj_MCRemoveMovie, 1,
755 "() -> (ComponentResult _rv)"},
756 {"MCIsPlayerEvent", (PyCFunction)MovieCtlObj_MCIsPlayerEvent, 1,
757 "(EventRecord e) -> (ComponentResult _rv)"},
758 {"MCDoAction", (PyCFunction)MovieCtlObj_MCDoAction, 1,
759 "(short action, void * params) -> (ComponentResult _rv)"},
760 {"MCSetControllerAttached", (PyCFunction)MovieCtlObj_MCSetControllerAttached, 1,
761 "(Boolean attach) -> (ComponentResult _rv)"},
762 {"MCIsControllerAttached", (PyCFunction)MovieCtlObj_MCIsControllerAttached, 1,
763 "() -> (ComponentResult _rv)"},
764 {"MCSetVisible", (PyCFunction)MovieCtlObj_MCSetVisible, 1,
765 "(Boolean visible) -> (ComponentResult _rv)"},
766 {"MCGetVisible", (PyCFunction)MovieCtlObj_MCGetVisible, 1,
767 "() -> (ComponentResult _rv)"},
768 {"MCGetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRect, 1,
769 "() -> (ComponentResult _rv, Rect bounds)"},
770 {"MCSetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCSetControllerBoundsRect, 1,
771 "(Rect bounds) -> (ComponentResult _rv)"},
772 {"MCGetControllerBoundsRgn", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRgn, 1,
773 "() -> (RgnHandle _rv)"},
774 {"MCGetWindowRgn", (PyCFunction)MovieCtlObj_MCGetWindowRgn, 1,
775 "(WindowPtr w) -> (RgnHandle _rv)"},
776 {"MCMovieChanged", (PyCFunction)MovieCtlObj_MCMovieChanged, 1,
777 "(Movie m) -> (ComponentResult _rv)"},
778 {"MCSetDuration", (PyCFunction)MovieCtlObj_MCSetDuration, 1,
779 "(TimeValue duration) -> (ComponentResult _rv)"},
780 {"MCGetCurrentTime", (PyCFunction)MovieCtlObj_MCGetCurrentTime, 1,
781 "() -> (TimeValue _rv, TimeScale scale)"},
782 {"MCNewAttachedController", (PyCFunction)MovieCtlObj_MCNewAttachedController, 1,
783 "(Movie theMovie, WindowPtr w, Point where) -> (ComponentResult _rv)"},
784 {"MCDraw", (PyCFunction)MovieCtlObj_MCDraw, 1,
785 "(WindowPtr w) -> (ComponentResult _rv)"},
786 {"MCActivate", (PyCFunction)MovieCtlObj_MCActivate, 1,
787 "(WindowPtr w, Boolean activate) -> (ComponentResult _rv)"},
788 {"MCIdle", (PyCFunction)MovieCtlObj_MCIdle, 1,
789 "() -> (ComponentResult _rv)"},
790 {"MCKey", (PyCFunction)MovieCtlObj_MCKey, 1,
791 "(SInt8 key, long modifiers) -> (ComponentResult _rv)"},
792 {"MCClick", (PyCFunction)MovieCtlObj_MCClick, 1,
793 "(WindowPtr w, Point where, long when, long modifiers) -> (ComponentResult _rv)"},
794 {"MCEnableEditing", (PyCFunction)MovieCtlObj_MCEnableEditing, 1,
795 "(Boolean enabled) -> (ComponentResult _rv)"},
796 {"MCIsEditingEnabled", (PyCFunction)MovieCtlObj_MCIsEditingEnabled, 1,
797 "() -> (long _rv)"},
798 {"MCCopy", (PyCFunction)MovieCtlObj_MCCopy, 1,
799 "() -> (Movie _rv)"},
800 {"MCCut", (PyCFunction)MovieCtlObj_MCCut, 1,
801 "() -> (Movie _rv)"},
802 {"MCPaste", (PyCFunction)MovieCtlObj_MCPaste, 1,
803 "(Movie srcMovie) -> (ComponentResult _rv)"},
804 {"MCClear", (PyCFunction)MovieCtlObj_MCClear, 1,
805 "() -> (ComponentResult _rv)"},
806 {"MCUndo", (PyCFunction)MovieCtlObj_MCUndo, 1,
807 "() -> (ComponentResult _rv)"},
808 {"MCPositionController", (PyCFunction)MovieCtlObj_MCPositionController, 1,
809 "(Rect movieRect, Rect controllerRect, long someFlags) -> (ComponentResult _rv)"},
810 {"MCGetControllerInfo", (PyCFunction)MovieCtlObj_MCGetControllerInfo, 1,
811 "() -> (ComponentResult _rv, long someFlags)"},
812 {"MCSetClip", (PyCFunction)MovieCtlObj_MCSetClip, 1,
813 "(RgnHandle theClip, RgnHandle movieClip) -> (ComponentResult _rv)"},
814 {"MCGetClip", (PyCFunction)MovieCtlObj_MCGetClip, 1,
815 "() -> (ComponentResult _rv, RgnHandle theClip, RgnHandle movieClip)"},
816 {"MCDrawBadge", (PyCFunction)MovieCtlObj_MCDrawBadge, 1,
817 "(RgnHandle movieRgn) -> (ComponentResult _rv, RgnHandle badgeRgn)"},
818 {"MCSetUpEditMenu", (PyCFunction)MovieCtlObj_MCSetUpEditMenu, 1,
819 "(long modifiers, MenuHandle mh) -> (ComponentResult _rv)"},
820 {"MCGetMenuString", (PyCFunction)MovieCtlObj_MCGetMenuString, 1,
821 "(long modifiers, short item, Str255 aString) -> (ComponentResult _rv)"},
822 {NULL, NULL, 0}
823 };
824
825 PyMethodChain MovieCtlObj_chain = { MovieCtlObj_methods, NULL };
826
827 static PyObject *MovieCtlObj_getattr(self, name)
828 MovieControllerObject *self;
829 char *name;
830 {
831 return Py_FindMethodInChain(&MovieCtlObj_chain, (PyObject *)self, name);
832 }
833
834 #define MovieCtlObj_setattr NULL
835
836 PyTypeObject MovieController_Type = {
837 PyObject_HEAD_INIT(&PyType_Type)
838 0, /*ob_size*/
839 "MovieController", /*tp_name*/
840 sizeof(MovieControllerObject), /*tp_basicsize*/
841 0, /*tp_itemsize*/
842 /* methods */
843 (destructor) MovieCtlObj_dealloc, /*tp_dealloc*/
844 0, /*tp_print*/
845 (getattrfunc) MovieCtlObj_getattr, /*tp_getattr*/
846 (setattrfunc) MovieCtlObj_setattr, /*tp_setattr*/
847 };
848
849 /* ---------------- End object type MovieController ----------------- */
850
851
852 /* ---------------------- Object type TimeBase ---------------------- */
853
854 PyTypeObject TimeBase_Type;
855
856 #define TimeBaseObj_Check(x) ((x)->ob_type == &TimeBase_Type)
857
858 typedef struct TimeBaseObject {
859 PyObject_HEAD
860 TimeBase ob_itself;
861 } TimeBaseObject;
862
863 PyObject *TimeBaseObj_New(itself)
864 TimeBase itself;
865 {
866 TimeBaseObject *it;
867 if (itself == NULL) {
868 PyErr_SetString(Qt_Error,"Cannot create null TimeBase");
869 return NULL;
870 }
871 it = PyObject_NEW(TimeBaseObject, &TimeBase_Type);
872 if (it == NULL) return NULL;
873 it->ob_itself = itself;
874 return (PyObject *)it;
875 }
876 TimeBaseObj_Convert(v, p_itself)
877 PyObject *v;
878 TimeBase *p_itself;
879 {
880 if (!TimeBaseObj_Check(v))
881 {
882 PyErr_SetString(PyExc_TypeError, "TimeBase required");
883 return 0;
884 }
885 *p_itself = ((TimeBaseObject *)v)->ob_itself;
886 return 1;
887 }
888
889 static void TimeBaseObj_dealloc(self)
890 TimeBaseObject *self;
891 {
892 DisposeTimeBase(self->ob_itself);
893 PyMem_DEL(self);
894 }
895
896 static PyObject *TimeBaseObj_SetTimeBaseValue(_self, _args)
897 TimeBaseObject *_self;
898 PyObject *_args;
899 {
900 PyObject *_res = NULL;
901 TimeValue t;
902 TimeScale s;
903 if (!PyArg_ParseTuple(_args, "ll",
904 &t,
905 &s))
906 return NULL;
907 SetTimeBaseValue(_self->ob_itself,
908 t,
909 s);
910 Py_INCREF(Py_None);
911 _res = Py_None;
912 return _res;
913 }
914
915 static PyObject *TimeBaseObj_GetTimeBaseRate(_self, _args)
916 TimeBaseObject *_self;
917 PyObject *_args;
918 {
919 PyObject *_res = NULL;
920 Fixed _rv;
921 if (!PyArg_ParseTuple(_args, ""))
922 return NULL;
923 _rv = GetTimeBaseRate(_self->ob_itself);
924 _res = Py_BuildValue("O&",
925 PyMac_BuildFixed, _rv);
926 return _res;
927 }
928
929 static PyObject *TimeBaseObj_SetTimeBaseRate(_self, _args)
930 TimeBaseObject *_self;
931 PyObject *_args;
932 {
933 PyObject *_res = NULL;
934 Fixed r;
935 if (!PyArg_ParseTuple(_args, "O&",
936 PyMac_GetFixed, &r))
937 return NULL;
938 SetTimeBaseRate(_self->ob_itself,
939 r);
940 Py_INCREF(Py_None);
941 _res = Py_None;
942 return _res;
943 }
944
945 static PyObject *TimeBaseObj_GetTimeBaseFlags(_self, _args)
946 TimeBaseObject *_self;
947 PyObject *_args;
948 {
949 PyObject *_res = NULL;
950 long _rv;
951 if (!PyArg_ParseTuple(_args, ""))
952 return NULL;
953 _rv = GetTimeBaseFlags(_self->ob_itself);
954 _res = Py_BuildValue("l",
955 _rv);
956 return _res;
957 }
958
959 static PyObject *TimeBaseObj_SetTimeBaseFlags(_self, _args)
960 TimeBaseObject *_self;
961 PyObject *_args;
962 {
963 PyObject *_res = NULL;
964 long timeBaseFlags;
965 if (!PyArg_ParseTuple(_args, "l",
966 &timeBaseFlags))
967 return NULL;
968 SetTimeBaseFlags(_self->ob_itself,
969 timeBaseFlags);
970 Py_INCREF(Py_None);
971 _res = Py_None;
972 return _res;
973 }
974
975 static PyObject *TimeBaseObj_GetTimeBaseMasterTimeBase(_self, _args)
976 TimeBaseObject *_self;
977 PyObject *_args;
978 {
979 PyObject *_res = NULL;
980 TimeBase _rv;
981 if (!PyArg_ParseTuple(_args, ""))
982 return NULL;
983 _rv = GetTimeBaseMasterTimeBase(_self->ob_itself);
984 _res = Py_BuildValue("O&",
985 TimeBaseObj_New, _rv);
986 return _res;
987 }
988
989 static PyObject *TimeBaseObj_GetTimeBaseMasterClock(_self, _args)
990 TimeBaseObject *_self;
991 PyObject *_args;
992 {
993 PyObject *_res = NULL;
994 ComponentInstance _rv;
995 if (!PyArg_ParseTuple(_args, ""))
996 return NULL;
997 _rv = GetTimeBaseMasterClock(_self->ob_itself);
998 _res = Py_BuildValue("O&",
999 CmpInstObj_New, _rv);
1000 return _res;
1001 }
1002
1003 static PyObject *TimeBaseObj_GetTimeBaseEffectiveRate(_self, _args)
1004 TimeBaseObject *_self;
1005 PyObject *_args;
1006 {
1007 PyObject *_res = NULL;
1008 Fixed _rv;
1009 if (!PyArg_ParseTuple(_args, ""))
1010 return NULL;
1011 _rv = GetTimeBaseEffectiveRate(_self->ob_itself);
1012 _res = Py_BuildValue("O&",
1013 PyMac_BuildFixed, _rv);
1014 return _res;
1015 }
1016
1017 static PyMethodDef TimeBaseObj_methods[] = {
1018 {"SetTimeBaseValue", (PyCFunction)TimeBaseObj_SetTimeBaseValue, 1,
1019 "(TimeValue t, TimeScale s) -> None"},
1020 {"GetTimeBaseRate", (PyCFunction)TimeBaseObj_GetTimeBaseRate, 1,
1021 "() -> (Fixed _rv)"},
1022 {"SetTimeBaseRate", (PyCFunction)TimeBaseObj_SetTimeBaseRate, 1,
1023 "(Fixed r) -> None"},
1024 {"GetTimeBaseFlags", (PyCFunction)TimeBaseObj_GetTimeBaseFlags, 1,
1025 "() -> (long _rv)"},
1026 {"SetTimeBaseFlags", (PyCFunction)TimeBaseObj_SetTimeBaseFlags, 1,
1027 "(long timeBaseFlags) -> None"},
1028 {"GetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_GetTimeBaseMasterTimeBase, 1,
1029 "() -> (TimeBase _rv)"},
1030 {"GetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_GetTimeBaseMasterClock, 1,
1031 "() -> (ComponentInstance _rv)"},
1032 {"GetTimeBaseEffectiveRate", (PyCFunction)TimeBaseObj_GetTimeBaseEffectiveRate, 1,
1033 "() -> (Fixed _rv)"},
1034 {NULL, NULL, 0}
1035 };
1036
1037 PyMethodChain TimeBaseObj_chain = { TimeBaseObj_methods, NULL };
1038
1039 static PyObject *TimeBaseObj_getattr(self, name)
1040 TimeBaseObject *self;
1041 char *name;
1042 {
1043 return Py_FindMethodInChain(&TimeBaseObj_chain, (PyObject *)self, name);
1044 }
1045
1046 #define TimeBaseObj_setattr NULL
1047
1048 PyTypeObject TimeBase_Type = {
1049 PyObject_HEAD_INIT(&PyType_Type)
1050 0, /*ob_size*/
1051 "TimeBase", /*tp_name*/
1052 sizeof(TimeBaseObject), /*tp_basicsize*/
1053 0, /*tp_itemsize*/
1054 /* methods */
1055 (destructor) TimeBaseObj_dealloc, /*tp_dealloc*/
1056 0, /*tp_print*/
1057 (getattrfunc) TimeBaseObj_getattr, /*tp_getattr*/
1058 (setattrfunc) TimeBaseObj_setattr, /*tp_setattr*/
1059 };
1060
1061 /* -------------------- End object type TimeBase -------------------- */
1062
1063
1064 /* ---------------------- Object type UserData ---------------------- */
1065
1066 PyTypeObject UserData_Type;
1067
1068 #define UserDataObj_Check(x) ((x)->ob_type == &UserData_Type)
1069
1070 typedef struct UserDataObject {
1071 PyObject_HEAD
1072 UserData ob_itself;
1073 } UserDataObject;
1074
1075 PyObject *UserDataObj_New(itself)
1076 UserData itself;
1077 {
1078 UserDataObject *it;
1079 if (itself == NULL) {
1080 PyErr_SetString(Qt_Error,"Cannot create null UserData");
1081 return NULL;
1082 }
1083 it = PyObject_NEW(UserDataObject, &UserData_Type);
1084 if (it == NULL) return NULL;
1085 it->ob_itself = itself;
1086 return (PyObject *)it;
1087 }
1088 UserDataObj_Convert(v, p_itself)
1089 PyObject *v;
1090 UserData *p_itself;
1091 {
1092 if (!UserDataObj_Check(v))
1093 {
1094 PyErr_SetString(PyExc_TypeError, "UserData required");
1095 return 0;
1096 }
1097 *p_itself = ((UserDataObject *)v)->ob_itself;
1098 return 1;
1099 }
1100
1101 static void UserDataObj_dealloc(self)
1102 UserDataObject *self;
1103 {
1104 DisposeUserData(self->ob_itself);
1105 PyMem_DEL(self);
1106 }
1107
1108 static PyObject *UserDataObj_GetUserData(_self, _args)
1109 UserDataObject *_self;
1110 PyObject *_args;
1111 {
1112 PyObject *_res = NULL;
1113 OSErr _err;
1114 Handle data;
1115 OSType udType;
1116 long index;
1117 if (!PyArg_ParseTuple(_args, "O&O&l",
1118 ResObj_Convert, &data,
1119 PyMac_GetOSType, &udType,
1120 &index))
1121 return NULL;
1122 _err = GetUserData(_self->ob_itself,
1123 data,
1124 udType,
1125 index);
1126 if (_err != noErr) return PyMac_Error(_err);
1127 Py_INCREF(Py_None);
1128 _res = Py_None;
1129 return _res;
1130 }
1131
1132 static PyObject *UserDataObj_AddUserData(_self, _args)
1133 UserDataObject *_self;
1134 PyObject *_args;
1135 {
1136 PyObject *_res = NULL;
1137 OSErr _err;
1138 Handle data;
1139 OSType udType;
1140 if (!PyArg_ParseTuple(_args, "O&O&",
1141 ResObj_Convert, &data,
1142 PyMac_GetOSType, &udType))
1143 return NULL;
1144 _err = AddUserData(_self->ob_itself,
1145 data,
1146 udType);
1147 if (_err != noErr) return PyMac_Error(_err);
1148 Py_INCREF(Py_None);
1149 _res = Py_None;
1150 return _res;
1151 }
1152
1153 static PyObject *UserDataObj_RemoveUserData(_self, _args)
1154 UserDataObject *_self;
1155 PyObject *_args;
1156 {
1157 PyObject *_res = NULL;
1158 OSErr _err;
1159 OSType udType;
1160 long index;
1161 if (!PyArg_ParseTuple(_args, "O&l",
1162 PyMac_GetOSType, &udType,
1163 &index))
1164 return NULL;
1165 _err = RemoveUserData(_self->ob_itself,
1166 udType,
1167 index);
1168 if (_err != noErr) return PyMac_Error(_err);
1169 Py_INCREF(Py_None);
1170 _res = Py_None;
1171 return _res;
1172 }
1173
1174 static PyObject *UserDataObj_CountUserDataType(_self, _args)
1175 UserDataObject *_self;
1176 PyObject *_args;
1177 {
1178 PyObject *_res = NULL;
1179 short _rv;
1180 OSType udType;
1181 if (!PyArg_ParseTuple(_args, "O&",
1182 PyMac_GetOSType, &udType))
1183 return NULL;
1184 _rv = CountUserDataType(_self->ob_itself,
1185 udType);
1186 _res = Py_BuildValue("h",
1187 _rv);
1188 return _res;
1189 }
1190
1191 static PyObject *UserDataObj_GetNextUserDataType(_self, _args)
1192 UserDataObject *_self;
1193 PyObject *_args;
1194 {
1195 PyObject *_res = NULL;
1196 long _rv;
1197 OSType udType;
1198 if (!PyArg_ParseTuple(_args, "O&",
1199 PyMac_GetOSType, &udType))
1200 return NULL;
1201 _rv = GetNextUserDataType(_self->ob_itself,
1202 udType);
1203 _res = Py_BuildValue("l",
1204 _rv);
1205 return _res;
1206 }
1207
1208 static PyObject *UserDataObj_AddUserDataText(_self, _args)
1209 UserDataObject *_self;
1210 PyObject *_args;
1211 {
1212 PyObject *_res = NULL;
1213 OSErr _err;
1214 Handle data;
1215 OSType udType;
1216 long index;
1217 short itlRegionTag;
1218 if (!PyArg_ParseTuple(_args, "O&O&lh",
1219 ResObj_Convert, &data,
1220 PyMac_GetOSType, &udType,
1221 &index,
1222 &itlRegionTag))
1223 return NULL;
1224 _err = AddUserDataText(_self->ob_itself,
1225 data,
1226 udType,
1227 index,
1228 itlRegionTag);
1229 if (_err != noErr) return PyMac_Error(_err);
1230 Py_INCREF(Py_None);
1231 _res = Py_None;
1232 return _res;
1233 }
1234
1235 static PyObject *UserDataObj_GetUserDataText(_self, _args)
1236 UserDataObject *_self;
1237 PyObject *_args;
1238 {
1239 PyObject *_res = NULL;
1240 OSErr _err;
1241 Handle data;
1242 OSType udType;
1243 long index;
1244 short itlRegionTag;
1245 if (!PyArg_ParseTuple(_args, "O&O&lh",
1246 ResObj_Convert, &data,
1247 PyMac_GetOSType, &udType,
1248 &index,
1249 &itlRegionTag))
1250 return NULL;
1251 _err = GetUserDataText(_self->ob_itself,
1252 data,
1253 udType,
1254 index,
1255 itlRegionTag);
1256 if (_err != noErr) return PyMac_Error(_err);
1257 Py_INCREF(Py_None);
1258 _res = Py_None;
1259 return _res;
1260 }
1261
1262 static PyObject *UserDataObj_RemoveUserDataText(_self, _args)
1263 UserDataObject *_self;
1264 PyObject *_args;
1265 {
1266 PyObject *_res = NULL;
1267 OSErr _err;
1268 OSType udType;
1269 long index;
1270 short itlRegionTag;
1271 if (!PyArg_ParseTuple(_args, "O&lh",
1272 PyMac_GetOSType, &udType,
1273 &index,
1274 &itlRegionTag))
1275 return NULL;
1276 _err = RemoveUserDataText(_self->ob_itself,
1277 udType,
1278 index,
1279 itlRegionTag);
1280 if (_err != noErr) return PyMac_Error(_err);
1281 Py_INCREF(Py_None);
1282 _res = Py_None;
1283 return _res;
1284 }
1285
1286 static PyObject *UserDataObj_PutUserDataIntoHandle(_self, _args)
1287 UserDataObject *_self;
1288 PyObject *_args;
1289 {
1290 PyObject *_res = NULL;
1291 OSErr _err;
1292 Handle h;
1293 if (!PyArg_ParseTuple(_args, "O&",
1294 ResObj_Convert, &h))
1295 return NULL;
1296 _err = PutUserDataIntoHandle(_self->ob_itself,
1297 h);
1298 if (_err != noErr) return PyMac_Error(_err);
1299 Py_INCREF(Py_None);
1300 _res = Py_None;
1301 return _res;
1302 }
1303
1304 static PyMethodDef UserDataObj_methods[] = {
1305 {"GetUserData", (PyCFunction)UserDataObj_GetUserData, 1,
1306 "(Handle data, OSType udType, long index) -> None"},
1307 {"AddUserData", (PyCFunction)UserDataObj_AddUserData, 1,
1308 "(Handle data, OSType udType) -> None"},
1309 {"RemoveUserData", (PyCFunction)UserDataObj_RemoveUserData, 1,
1310 "(OSType udType, long index) -> None"},
1311 {"CountUserDataType", (PyCFunction)UserDataObj_CountUserDataType, 1,
1312 "(OSType udType) -> (short _rv)"},
1313 {"GetNextUserDataType", (PyCFunction)UserDataObj_GetNextUserDataType, 1,
1314 "(OSType udType) -> (long _rv)"},
1315 {"AddUserDataText", (PyCFunction)UserDataObj_AddUserDataText, 1,
1316 "(Handle data, OSType udType, long index, short itlRegionTag) -> None"},
1317 {"GetUserDataText", (PyCFunction)UserDataObj_GetUserDataText, 1,
1318 "(Handle data, OSType udType, long index, short itlRegionTag) -> None"},
1319 {"RemoveUserDataText", (PyCFunction)UserDataObj_RemoveUserDataText, 1,
1320 "(OSType udType, long index, short itlRegionTag) -> None"},
1321 {"PutUserDataIntoHandle", (PyCFunction)UserDataObj_PutUserDataIntoHandle, 1,
1322 "(Handle h) -> None"},
1323 {NULL, NULL, 0}
1324 };
1325
1326 PyMethodChain UserDataObj_chain = { UserDataObj_methods, NULL };
1327
1328 static PyObject *UserDataObj_getattr(self, name)
1329 UserDataObject *self;
1330 char *name;
1331 {
1332 return Py_FindMethodInChain(&UserDataObj_chain, (PyObject *)self, name);
1333 }
1334
1335 #define UserDataObj_setattr NULL
1336
1337 PyTypeObject UserData_Type = {
1338 PyObject_HEAD_INIT(&PyType_Type)
1339 0, /*ob_size*/
1340 "UserData", /*tp_name*/
1341 sizeof(UserDataObject), /*tp_basicsize*/
1342 0, /*tp_itemsize*/
1343 /* methods */
1344 (destructor) UserDataObj_dealloc, /*tp_dealloc*/
1345 0, /*tp_print*/
1346 (getattrfunc) UserDataObj_getattr, /*tp_getattr*/
1347 (setattrfunc) UserDataObj_setattr, /*tp_setattr*/
1348 };
1349
1350 /* -------------------- End object type UserData -------------------- */
1351
1352
1353 /* ----------------------- Object type Media ------------------------ */
1354
1355 PyTypeObject Media_Type;
1356
1357 #define MediaObj_Check(x) ((x)->ob_type == &Media_Type)
1358
1359 typedef struct MediaObject {
1360 PyObject_HEAD
1361 Media ob_itself;
1362 } MediaObject;
1363
1364 PyObject *MediaObj_New(itself)
1365 Media itself;
1366 {
1367 MediaObject *it;
1368 if (itself == NULL) {
1369 PyErr_SetString(Qt_Error,"Cannot create null Media");
1370 return NULL;
1371 }
1372 it = PyObject_NEW(MediaObject, &Media_Type);
1373 if (it == NULL) return NULL;
1374 it->ob_itself = itself;
1375 return (PyObject *)it;
1376 }
1377 MediaObj_Convert(v, p_itself)
1378 PyObject *v;
1379 Media *p_itself;
1380 {
1381 if (!MediaObj_Check(v))
1382 {
1383 PyErr_SetString(PyExc_TypeError, "Media required");
1384 return 0;
1385 }
1386 *p_itself = ((MediaObject *)v)->ob_itself;
1387 return 1;
1388 }
1389
1390 static void MediaObj_dealloc(self)
1391 MediaObject *self;
1392 {
1393 DisposeTrackMedia(self->ob_itself);
1394 PyMem_DEL(self);
1395 }
1396
1397 static PyObject *MediaObj_LoadMediaIntoRam(_self, _args)
1398 MediaObject *_self;
1399 PyObject *_args;
1400 {
1401 PyObject *_res = NULL;
1402 OSErr _err;
1403 TimeValue time;
1404 TimeValue duration;
1405 long flags;
1406 if (!PyArg_ParseTuple(_args, "lll",
1407 &time,
1408 &duration,
1409 &flags))
1410 return NULL;
1411 _err = LoadMediaIntoRam(_self->ob_itself,
1412 time,
1413 duration,
1414 flags);
1415 if (_err != noErr) return PyMac_Error(_err);
1416 Py_INCREF(Py_None);
1417 _res = Py_None;
1418 return _res;
1419 }
1420
1421 static PyObject *MediaObj_GetMediaTrack(_self, _args)
1422 MediaObject *_self;
1423 PyObject *_args;
1424 {
1425 PyObject *_res = NULL;
1426 Track _rv;
1427 if (!PyArg_ParseTuple(_args, ""))
1428 return NULL;
1429 _rv = GetMediaTrack(_self->ob_itself);
1430 _res = Py_BuildValue("O&",
1431 TrackObj_New, _rv);
1432 return _res;
1433 }
1434
1435 static PyObject *MediaObj_GetMediaTimeScale(_self, _args)
1436 MediaObject *_self;
1437 PyObject *_args;
1438 {
1439 PyObject *_res = NULL;
1440 TimeScale _rv;
1441 if (!PyArg_ParseTuple(_args, ""))
1442 return NULL;
1443 _rv = GetMediaTimeScale(_self->ob_itself);
1444 _res = Py_BuildValue("l",
1445 _rv);
1446 return _res;
1447 }
1448
1449 static PyObject *MediaObj_SetMediaTimeScale(_self, _args)
1450 MediaObject *_self;
1451 PyObject *_args;
1452 {
1453 PyObject *_res = NULL;
1454 TimeScale timeScale;
1455 if (!PyArg_ParseTuple(_args, "l",
1456 &timeScale))
1457 return NULL;
1458 SetMediaTimeScale(_self->ob_itself,
1459 timeScale);
1460 Py_INCREF(Py_None);
1461 _res = Py_None;
1462 return _res;
1463 }
1464
1465 static PyObject *MediaObj_GetMediaDuration(_self, _args)
1466 MediaObject *_self;
1467 PyObject *_args;
1468 {
1469 PyObject *_res = NULL;
1470 TimeValue _rv;
1471 if (!PyArg_ParseTuple(_args, ""))
1472 return NULL;
1473 _rv = GetMediaDuration(_self->ob_itself);
1474 _res = Py_BuildValue("l",
1475 _rv);
1476 return _res;
1477 }
1478
1479 static PyObject *MediaObj_GetMediaLanguage(_self, _args)
1480 MediaObject *_self;
1481 PyObject *_args;
1482 {
1483 PyObject *_res = NULL;
1484 short _rv;
1485 if (!PyArg_ParseTuple(_args, ""))
1486 return NULL;
1487 _rv = GetMediaLanguage(_self->ob_itself);
1488 _res = Py_BuildValue("h",
1489 _rv);
1490 return _res;
1491 }
1492
1493 static PyObject *MediaObj_SetMediaLanguage(_self, _args)
1494 MediaObject *_self;
1495 PyObject *_args;
1496 {
1497 PyObject *_res = NULL;
1498 short language;
1499 if (!PyArg_ParseTuple(_args, "h",
1500 &language))
1501 return NULL;
1502 SetMediaLanguage(_self->ob_itself,
1503 language);
1504 Py_INCREF(Py_None);
1505 _res = Py_None;
1506 return _res;
1507 }
1508
1509 static PyObject *MediaObj_GetMediaQuality(_self, _args)
1510 MediaObject *_self;
1511 PyObject *_args;
1512 {
1513 PyObject *_res = NULL;
1514 short _rv;
1515 if (!PyArg_ParseTuple(_args, ""))
1516 return NULL;
1517 _rv = GetMediaQuality(_self->ob_itself);
1518 _res = Py_BuildValue("h",
1519 _rv);
1520 return _res;
1521 }
1522
1523 static PyObject *MediaObj_SetMediaQuality(_self, _args)
1524 MediaObject *_self;
1525 PyObject *_args;
1526 {
1527 PyObject *_res = NULL;
1528 short quality;
1529 if (!PyArg_ParseTuple(_args, "h",
1530 &quality))
1531 return NULL;
1532 SetMediaQuality(_self->ob_itself,
1533 quality);
1534 Py_INCREF(Py_None);
1535 _res = Py_None;
1536 return _res;
1537 }
1538
1539 static PyObject *MediaObj_GetMediaHandlerDescription(_self, _args)
1540 MediaObject *_self;
1541 PyObject *_args;
1542 {
1543 PyObject *_res = NULL;
1544 OSType mediaType;
1545 Str255 creatorName;
1546 OSType creatorManufacturer;
1547 if (!PyArg_ParseTuple(_args, "O&",
1548 PyMac_GetStr255, creatorName))
1549 return NULL;
1550 GetMediaHandlerDescription(_self->ob_itself,
1551 &mediaType,
1552 creatorName,
1553 &creatorManufacturer);
1554 _res = Py_BuildValue("O&O&",
1555 PyMac_BuildOSType, mediaType,
1556 PyMac_BuildOSType, creatorManufacturer);
1557 return _res;
1558 }
1559
1560 static PyObject *MediaObj_GetMediaUserData(_self, _args)
1561 MediaObject *_self;
1562 PyObject *_args;
1563 {
1564 PyObject *_res = NULL;
1565 UserData _rv;
1566 if (!PyArg_ParseTuple(_args, ""))
1567 return NULL;
1568 _rv = GetMediaUserData(_self->ob_itself);
1569 _res = Py_BuildValue("O&",
1570 UserDataObj_New, _rv);
1571 return _res;
1572 }
1573
1574 static PyObject *MediaObj_GetMediaHandler(_self, _args)
1575 MediaObject *_self;
1576 PyObject *_args;
1577 {
1578 PyObject *_res = NULL;
1579 MediaHandler _rv;
1580 if (!PyArg_ParseTuple(_args, ""))
1581 return NULL;
1582 _rv = GetMediaHandler(_self->ob_itself);
1583 _res = Py_BuildValue("O&",
1584 CmpInstObj_New, _rv);
1585 return _res;
1586 }
1587
1588 static PyObject *MediaObj_SetMediaHandler(_self, _args)
1589 MediaObject *_self;
1590 PyObject *_args;
1591 {
1592 PyObject *_res = NULL;
1593 OSErr _err;
1594 MediaHandlerComponent mH;
1595 if (!PyArg_ParseTuple(_args, "O&",
1596 CmpObj_Convert, &mH))
1597 return NULL;
1598 _err = SetMediaHandler(_self->ob_itself,
1599 mH);
1600 if (_err != noErr) return PyMac_Error(_err);
1601 Py_INCREF(Py_None);
1602 _res = Py_None;
1603 return _res;
1604 }
1605
1606 static PyObject *MediaObj_BeginMediaEdits(_self, _args)
1607 MediaObject *_self;
1608 PyObject *_args;
1609 {
1610 PyObject *_res = NULL;
1611 OSErr _err;
1612 if (!PyArg_ParseTuple(_args, ""))
1613 return NULL;
1614 _err = BeginMediaEdits(_self->ob_itself);
1615 if (_err != noErr) return PyMac_Error(_err);
1616 Py_INCREF(Py_None);
1617 _res = Py_None;
1618 return _res;
1619 }
1620
1621 static PyObject *MediaObj_EndMediaEdits(_self, _args)
1622 MediaObject *_self;
1623 PyObject *_args;
1624 {
1625 PyObject *_res = NULL;
1626 OSErr _err;
1627 if (!PyArg_ParseTuple(_args, ""))
1628 return NULL;
1629 _err = EndMediaEdits(_self->ob_itself);
1630 if (_err != noErr) return PyMac_Error(_err);
1631 Py_INCREF(Py_None);
1632 _res = Py_None;
1633 return _res;
1634 }
1635
1636 static PyObject *MediaObj_SetMediaDefaultDataRefIndex(_self, _args)
1637 MediaObject *_self;
1638 PyObject *_args;
1639 {
1640 PyObject *_res = NULL;
1641 OSErr _err;
1642 short index;
1643 if (!PyArg_ParseTuple(_args, "h",
1644 &index))
1645 return NULL;
1646 _err = SetMediaDefaultDataRefIndex(_self->ob_itself,
1647 index);
1648 if (_err != noErr) return PyMac_Error(_err);
1649 Py_INCREF(Py_None);
1650 _res = Py_None;
1651 return _res;
1652 }
1653
1654 static PyObject *MediaObj_GetMediaDataHandlerDescription(_self, _args)
1655 MediaObject *_self;
1656 PyObject *_args;
1657 {
1658 PyObject *_res = NULL;
1659 short index;
1660 OSType dhType;
1661 Str255 creatorName;
1662 OSType creatorManufacturer;
1663 if (!PyArg_ParseTuple(_args, "hO&",
1664 &index,
1665 PyMac_GetStr255, creatorName))
1666 return NULL;
1667 GetMediaDataHandlerDescription(_self->ob_itself,
1668 index,
1669 &dhType,
1670 creatorName,
1671 &creatorManufacturer);
1672 _res = Py_BuildValue("O&O&",
1673 PyMac_BuildOSType, dhType,
1674 PyMac_BuildOSType, creatorManufacturer);
1675 return _res;
1676 }
1677
1678 static PyObject *MediaObj_GetMediaDataHandler(_self, _args)
1679 MediaObject *_self;
1680 PyObject *_args;
1681 {
1682 PyObject *_res = NULL;
1683 DataHandler _rv;
1684 short index;
1685 if (!PyArg_ParseTuple(_args, "h",
1686 &index))
1687 return NULL;
1688 _rv = GetMediaDataHandler(_self->ob_itself,
1689 index);
1690 _res = Py_BuildValue("O&",
1691 CmpInstObj_New, _rv);
1692 return _res;
1693 }
1694
1695 static PyObject *MediaObj_SetMediaDataHandler(_self, _args)
1696 MediaObject *_self;
1697 PyObject *_args;
1698 {
1699 PyObject *_res = NULL;
1700 OSErr _err;
1701 short index;
1702 DataHandlerComponent dataHandler;
1703 if (!PyArg_ParseTuple(_args, "hO&",
1704 &index,
1705 CmpObj_Convert, &dataHandler))
1706 return NULL;
1707 _err = SetMediaDataHandler(_self->ob_itself,
1708 index,
1709 dataHandler);
1710 if (_err != noErr) return PyMac_Error(_err);
1711 Py_INCREF(Py_None);
1712 _res = Py_None;
1713 return _res;
1714 }
1715
1716 static PyObject *MediaObj_GetMediaSampleDescriptionCount(_self, _args)
1717 MediaObject *_self;
1718 PyObject *_args;
1719 {
1720 PyObject *_res = NULL;
1721 long _rv;
1722 if (!PyArg_ParseTuple(_args, ""))
1723 return NULL;
1724 _rv = GetMediaSampleDescriptionCount(_self->ob_itself);
1725 _res = Py_BuildValue("l",
1726 _rv);
1727 return _res;
1728 }
1729
1730 static PyObject *MediaObj_GetMediaSampleDescription(_self, _args)
1731 MediaObject *_self;
1732 PyObject *_args;
1733 {
1734 PyObject *_res = NULL;
1735 long index;
1736 SampleDescriptionHandle descH;
1737 if (!PyArg_ParseTuple(_args, "lO&",
1738 &index,
1739 ResObj_Convert, &descH))
1740 return NULL;
1741 GetMediaSampleDescription(_self->ob_itself,
1742 index,
1743 descH);
1744 Py_INCREF(Py_None);
1745 _res = Py_None;
1746 return _res;
1747 }
1748
1749 static PyObject *MediaObj_SetMediaSampleDescription(_self, _args)
1750 MediaObject *_self;
1751 PyObject *_args;
1752 {
1753 PyObject *_res = NULL;
1754 OSErr _err;
1755 long index;
1756 SampleDescriptionHandle descH;
1757 if (!PyArg_ParseTuple(_args, "lO&",
1758 &index,
1759 ResObj_Convert, &descH))
1760 return NULL;
1761 _err = SetMediaSampleDescription(_self->ob_itself,
1762 index,
1763 descH);
1764 if (_err != noErr) return PyMac_Error(_err);
1765 Py_INCREF(Py_None);
1766 _res = Py_None;
1767 return _res;
1768 }
1769
1770 static PyObject *MediaObj_GetMediaSampleCount(_self, _args)
1771 MediaObject *_self;
1772 PyObject *_args;
1773 {
1774 PyObject *_res = NULL;
1775 long _rv;
1776 if (!PyArg_ParseTuple(_args, ""))
1777 return NULL;
1778 _rv = GetMediaSampleCount(_self->ob_itself);
1779 _res = Py_BuildValue("l",
1780 _rv);
1781 return _res;
1782 }
1783
1784 static PyObject *MediaObj_SampleNumToMediaTime(_self, _args)
1785 MediaObject *_self;
1786 PyObject *_args;
1787 {
1788 PyObject *_res = NULL;
1789 long logicalSampleNum;
1790 TimeValue sampleTime;
1791 TimeValue sampleDuration;
1792 if (!PyArg_ParseTuple(_args, "l",
1793 &logicalSampleNum))
1794 return NULL;
1795 SampleNumToMediaTime(_self->ob_itself,
1796 logicalSampleNum,
1797 &sampleTime,
1798 &sampleDuration);
1799 _res = Py_BuildValue("ll",
1800 sampleTime,
1801 sampleDuration);
1802 return _res;
1803 }
1804
1805 static PyObject *MediaObj_MediaTimeToSampleNum(_self, _args)
1806 MediaObject *_self;
1807 PyObject *_args;
1808 {
1809 PyObject *_res = NULL;
1810 TimeValue time;
1811 long sampleNum;
1812 TimeValue sampleTime;
1813 TimeValue sampleDuration;
1814 if (!PyArg_ParseTuple(_args, "l",
1815 &time))
1816 return NULL;
1817 MediaTimeToSampleNum(_self->ob_itself,
1818 time,
1819 &sampleNum,
1820 &sampleTime,
1821 &sampleDuration);
1822 _res = Py_BuildValue("lll",
1823 sampleNum,
1824 sampleTime,
1825 sampleDuration);
1826 return _res;
1827 }
1828
1829 static PyObject *MediaObj_AddMediaSample(_self, _args)
1830 MediaObject *_self;
1831 PyObject *_args;
1832 {
1833 PyObject *_res = NULL;
1834 OSErr _err;
1835 Handle dataIn;
1836 long inOffset;
1837 unsigned long size;
1838 TimeValue durationPerSample;
1839 SampleDescriptionHandle sampleDescriptionH;
1840 long numberOfSamples;
1841 short sampleFlags;
1842 TimeValue sampleTime;
1843 if (!PyArg_ParseTuple(_args, "O&lllO&lh",
1844 ResObj_Convert, &dataIn,
1845 &inOffset,
1846 &size,
1847 &durationPerSample,
1848 ResObj_Convert, &sampleDescriptionH,
1849 &numberOfSamples,
1850 &sampleFlags))
1851 return NULL;
1852 _err = AddMediaSample(_self->ob_itself,
1853 dataIn,
1854 inOffset,
1855 size,
1856 durationPerSample,
1857 sampleDescriptionH,
1858 numberOfSamples,
1859 sampleFlags,
1860 &sampleTime);
1861 if (_err != noErr) return PyMac_Error(_err);
1862 _res = Py_BuildValue("l",
1863 sampleTime);
1864 return _res;
1865 }
1866
1867 static PyObject *MediaObj_AddMediaSampleReference(_self, _args)
1868 MediaObject *_self;
1869 PyObject *_args;
1870 {
1871 PyObject *_res = NULL;
1872 OSErr _err;
1873 long dataOffset;
1874 unsigned long size;
1875 TimeValue durationPerSample;
1876 SampleDescriptionHandle sampleDescriptionH;
1877 long numberOfSamples;
1878 short sampleFlags;
1879 TimeValue sampleTime;
1880 if (!PyArg_ParseTuple(_args, "lllO&lh",
1881 &dataOffset,
1882 &size,
1883 &durationPerSample,
1884 ResObj_Convert, &sampleDescriptionH,
1885 &numberOfSamples,
1886 &sampleFlags))
1887 return NULL;
1888 _err = AddMediaSampleReference(_self->ob_itself,
1889 dataOffset,
1890 size,
1891 durationPerSample,
1892 sampleDescriptionH,
1893 numberOfSamples,
1894 sampleFlags,
1895 &sampleTime);
1896 if (_err != noErr) return PyMac_Error(_err);
1897 _res = Py_BuildValue("l",
1898 sampleTime);
1899 return _res;
1900 }
1901
1902 static PyObject *MediaObj_GetMediaSample(_self, _args)
1903 MediaObject *_self;
1904 PyObject *_args;
1905 {
1906 PyObject *_res = NULL;
1907 OSErr _err;
1908 Handle dataOut;
1909 long maxSizeToGrow;
1910 long size;
1911 TimeValue time;
1912 TimeValue sampleTime;
1913 TimeValue durationPerSample;
1914 SampleDescriptionHandle sampleDescriptionH;
1915 long sampleDescriptionIndex;
1916 long maxNumberOfSamples;
1917 long numberOfSamples;
1918 short sampleFlags;
1919 if (!PyArg_ParseTuple(_args, "O&llO&l",
1920 ResObj_Convert, &dataOut,
1921 &maxSizeToGrow,
1922 &time,
1923 ResObj_Convert, &sampleDescriptionH,
1924 &maxNumberOfSamples))
1925 return NULL;
1926 _err = GetMediaSample(_self->ob_itself,
1927 dataOut,
1928 maxSizeToGrow,
1929 &size,
1930 time,
1931 &sampleTime,
1932 &durationPerSample,
1933 sampleDescriptionH,
1934 &sampleDescriptionIndex,
1935 maxNumberOfSamples,
1936 &numberOfSamples,
1937 &sampleFlags);
1938 if (_err != noErr) return PyMac_Error(_err);
1939 _res = Py_BuildValue("lllllh",
1940 size,
1941 sampleTime,
1942 durationPerSample,
1943 sampleDescriptionIndex,
1944 numberOfSamples,
1945 sampleFlags);
1946 return _res;
1947 }
1948
1949 static PyObject *MediaObj_GetMediaSampleReference(_self, _args)
1950 MediaObject *_self;
1951 PyObject *_args;
1952 {
1953 PyObject *_res = NULL;
1954 OSErr _err;
1955 long dataOffset;
1956 long size;
1957 TimeValue time;
1958 TimeValue sampleTime;
1959 TimeValue durationPerSample;
1960 SampleDescriptionHandle sampleDescriptionH;
1961 long sampleDescriptionIndex;
1962 long maxNumberOfSamples;
1963 long numberOfSamples;
1964 short sampleFlags;
1965 if (!PyArg_ParseTuple(_args, "lO&l",
1966 &time,
1967 ResObj_Convert, &sampleDescriptionH,
1968 &maxNumberOfSamples))
1969 return NULL;
1970 _err = GetMediaSampleReference(_self->ob_itself,
1971 &dataOffset,
1972 &size,
1973 time,
1974 &sampleTime,
1975 &durationPerSample,
1976 sampleDescriptionH,
1977 &sampleDescriptionIndex,
1978 maxNumberOfSamples,
1979 &numberOfSamples,
1980 &sampleFlags);
1981 if (_err != noErr) return PyMac_Error(_err);
1982 _res = Py_BuildValue("llllllh",
1983 dataOffset,
1984 size,
1985 sampleTime,
1986 durationPerSample,
1987 sampleDescriptionIndex,
1988 numberOfSamples,
1989 sampleFlags);
1990 return _res;
1991 }
1992
1993 static PyObject *MediaObj_SetMediaPreferredChunkSize(_self, _args)
1994 MediaObject *_self;
1995 PyObject *_args;
1996 {
1997 PyObject *_res = NULL;
1998 OSErr _err;
1999 long maxChunkSize;
2000 if (!PyArg_ParseTuple(_args, "l",
2001 &maxChunkSize))
2002 return NULL;
2003 _err = SetMediaPreferredChunkSize(_self->ob_itself,
2004 maxChunkSize);
2005 if (_err != noErr) return PyMac_Error(_err);
2006 Py_INCREF(Py_None);
2007 _res = Py_None;
2008 return _res;
2009 }
2010
2011 static PyObject *MediaObj_GetMediaPreferredChunkSize(_self, _args)
2012 MediaObject *_self;
2013 PyObject *_args;
2014 {
2015 PyObject *_res = NULL;
2016 OSErr _err;
2017 long maxChunkSize;
2018 if (!PyArg_ParseTuple(_args, ""))
2019 return NULL;
2020 _err = GetMediaPreferredChunkSize(_self->ob_itself,
2021 &maxChunkSize);
2022 if (_err != noErr) return PyMac_Error(_err);
2023 _res = Py_BuildValue("l",
2024 maxChunkSize);
2025 return _res;
2026 }
2027
2028 static PyObject *MediaObj_SetMediaShadowSync(_self, _args)
2029 MediaObject *_self;
2030 PyObject *_args;
2031 {
2032 PyObject *_res = NULL;
2033 OSErr _err;
2034 long frameDiffSampleNum;
2035 long syncSampleNum;
2036 if (!PyArg_ParseTuple(_args, "ll",
2037 &frameDiffSampleNum,
2038 &syncSampleNum))
2039 return NULL;
2040 _err = SetMediaShadowSync(_self->ob_itself,
2041 frameDiffSampleNum,
2042 syncSampleNum);
2043 if (_err != noErr) return PyMac_Error(_err);
2044 Py_INCREF(Py_None);
2045 _res = Py_None;
2046 return _res;
2047 }
2048
2049 static PyObject *MediaObj_GetMediaShadowSync(_self, _args)
2050 MediaObject *_self;
2051 PyObject *_args;
2052 {
2053 PyObject *_res = NULL;
2054 OSErr _err;
2055 long frameDiffSampleNum;
2056 long syncSampleNum;
2057 if (!PyArg_ParseTuple(_args, "l",
2058 &frameDiffSampleNum))
2059 return NULL;
2060 _err = GetMediaShadowSync(_self->ob_itself,
2061 frameDiffSampleNum,
2062 &syncSampleNum);
2063 if (_err != noErr) return PyMac_Error(_err);
2064 _res = Py_BuildValue("l",
2065 syncSampleNum);
2066 return _res;
2067 }
2068
2069 static PyObject *MediaObj_GetMediaDataSize(_self, _args)
2070 MediaObject *_self;
2071 PyObject *_args;
2072 {
2073 PyObject *_res = NULL;
2074 long _rv;
2075 TimeValue startTime;
2076 TimeValue duration;
2077 if (!PyArg_ParseTuple(_args, "ll",
2078 &startTime,
2079 &duration))
2080 return NULL;
2081 _rv = GetMediaDataSize(_self->ob_itself,
2082 startTime,
2083 duration);
2084 _res = Py_BuildValue("l",
2085 _rv);
2086 return _res;
2087 }
2088
2089 static PyObject *MediaObj_GetMediaNextInterestingTime(_self, _args)
2090 MediaObject *_self;
2091 PyObject *_args;
2092 {
2093 PyObject *_res = NULL;
2094 short interestingTimeFlags;
2095 TimeValue time;
2096 Fixed rate;
2097 TimeValue interestingTime;
2098 TimeValue interestingDuration;
2099 if (!PyArg_ParseTuple(_args, "hlO&",
2100 &interestingTimeFlags,
2101 &time,
2102 PyMac_GetFixed, &rate))
2103 return NULL;
2104 GetMediaNextInterestingTime(_self->ob_itself,
2105 interestingTimeFlags,
2106 time,
2107 rate,
2108 &interestingTime,
2109 &interestingDuration);
2110 _res = Py_BuildValue("ll",
2111 interestingTime,
2112 interestingDuration);
2113 return _res;
2114 }
2115
2116 static PyObject *MediaObj_GetMediaDataRef(_self, _args)
2117 MediaObject *_self;
2118 PyObject *_args;
2119 {
2120 PyObject *_res = NULL;
2121 OSErr _err;
2122 short index;
2123 Handle dataRef;
2124 OSType dataRefType;
2125 long dataRefAttributes;
2126 if (!PyArg_ParseTuple(_args, "h",
2127 &index))
2128 return NULL;
2129 _err = GetMediaDataRef(_self->ob_itself,
2130 index,
2131 &dataRef,
2132 &dataRefType,
2133 &dataRefAttributes);
2134 if (_err != noErr) return PyMac_Error(_err);
2135 _res = Py_BuildValue("O&O&l",
2136 ResObj_New, dataRef,
2137 PyMac_BuildOSType, dataRefType,
2138 dataRefAttributes);
2139 return _res;
2140 }
2141
2142 static PyObject *MediaObj_SetMediaDataRef(_self, _args)
2143 MediaObject *_self;
2144 PyObject *_args;
2145 {
2146 PyObject *_res = NULL;
2147 OSErr _err;
2148 short index;
2149 Handle dataRef;
2150 OSType dataRefType;
2151 if (!PyArg_ParseTuple(_args, "hO&O&",
2152 &index,
2153 ResObj_Convert, &dataRef,
2154 PyMac_GetOSType, &dataRefType))
2155 return NULL;
2156 _err = SetMediaDataRef(_self->ob_itself,
2157 index,
2158 dataRef,
2159 dataRefType);
2160 if (_err != noErr) return PyMac_Error(_err);
2161 Py_INCREF(Py_None);
2162 _res = Py_None;
2163 return _res;
2164 }
2165
2166 static PyObject *MediaObj_SetMediaDataRefAttributes(_self, _args)
2167 MediaObject *_self;
2168 PyObject *_args;
2169 {
2170 PyObject *_res = NULL;
2171 OSErr _err;
2172 short index;
2173 long dataRefAttributes;
2174 if (!PyArg_ParseTuple(_args, "hl",
2175 &index,
2176 &dataRefAttributes))
2177 return NULL;
2178 _err = SetMediaDataRefAttributes(_self->ob_itself,
2179 index,
2180 dataRefAttributes);
2181 if (_err != noErr) return PyMac_Error(_err);
2182 Py_INCREF(Py_None);
2183 _res = Py_None;
2184 return _res;
2185 }
2186
2187 static PyObject *MediaObj_AddMediaDataRef(_self, _args)
2188 MediaObject *_self;
2189 PyObject *_args;
2190 {
2191 PyObject *_res = NULL;
2192 OSErr _err;
2193 short index;
2194 Handle dataRef;
2195 OSType dataRefType;
2196 if (!PyArg_ParseTuple(_args, "O&O&",
2197 ResObj_Convert, &dataRef,
2198 PyMac_GetOSType, &dataRefType))
2199 return NULL;
2200 _err = AddMediaDataRef(_self->ob_itself,
2201 &index,
2202 dataRef,
2203 dataRefType);
2204 if (_err != noErr) return PyMac_Error(_err);
2205 _res = Py_BuildValue("h",
2206 index);
2207 return _res;
2208 }
2209
2210 static PyObject *MediaObj_GetMediaDataRefCount(_self, _args)
2211 MediaObject *_self;
2212 PyObject *_args;
2213 {
2214 PyObject *_res = NULL;
2215 OSErr _err;
2216 short count;
2217 if (!PyArg_ParseTuple(_args, ""))
2218 return NULL;
2219 _err = GetMediaDataRefCount(_self->ob_itself,
2220 &count);
2221 if (_err != noErr) return PyMac_Error(_err);
2222 _res = Py_BuildValue("h",
2223 count);
2224 return _res;
2225 }
2226
2227 static PyObject *MediaObj_SetMediaPlayHints(_self, _args)
2228 MediaObject *_self;
2229 PyObject *_args;
2230 {
2231 PyObject *_res = NULL;
2232 long flags;
2233 long flagsMask;
2234 if (!PyArg_ParseTuple(_args, "ll",
2235 &flags,
2236 &flagsMask))
2237 return NULL;
2238 SetMediaPlayHints(_self->ob_itself,
2239 flags,
2240 flagsMask);
2241 Py_INCREF(Py_None);
2242 _res = Py_None;
2243 return _res;
2244 }
2245
2246 static PyMethodDef MediaObj_methods[] = {
2247 {"LoadMediaIntoRam", (PyCFunction)MediaObj_LoadMediaIntoRam, 1,
2248 "(TimeValue time, TimeValue duration, long flags) -> None"},
2249 {"GetMediaTrack", (PyCFunction)MediaObj_GetMediaTrack, 1,
2250 "() -> (Track _rv)"},
2251 {"GetMediaTimeScale", (PyCFunction)MediaObj_GetMediaTimeScale, 1,
2252 "() -> (TimeScale _rv)"},
2253 {"SetMediaTimeScale", (PyCFunction)MediaObj_SetMediaTimeScale, 1,
2254 "(TimeScale timeScale) -> None"},
2255 {"GetMediaDuration", (PyCFunction)MediaObj_GetMediaDuration, 1,
2256 "() -> (TimeValue _rv)"},
2257 {"GetMediaLanguage", (PyCFunction)MediaObj_GetMediaLanguage, 1,
2258 "() -> (short _rv)"},
2259 {"SetMediaLanguage", (PyCFunction)MediaObj_SetMediaLanguage, 1,
2260 "(short language) -> None"},
2261 {"GetMediaQuality", (PyCFunction)MediaObj_GetMediaQuality, 1,
2262 "() -> (short _rv)"},
2263 {"SetMediaQuality", (PyCFunction)MediaObj_SetMediaQuality, 1,
2264 "(short quality) -> None"},
2265 {"GetMediaHandlerDescription", (PyCFunction)MediaObj_GetMediaHandlerDescription, 1,
2266 "(Str255 creatorName) -> (OSType mediaType, OSType creatorManufacturer)"},
2267 {"GetMediaUserData", (PyCFunction)MediaObj_GetMediaUserData, 1,
2268 "() -> (UserData _rv)"},
2269 {"GetMediaHandler", (PyCFunction)MediaObj_GetMediaHandler, 1,
2270 "() -> (MediaHandler _rv)"},
2271 {"SetMediaHandler", (PyCFunction)MediaObj_SetMediaHandler, 1,
2272 "(MediaHandlerComponent mH) -> None"},
2273 {"BeginMediaEdits", (PyCFunction)MediaObj_BeginMediaEdits, 1,
2274 "() -> None"},
2275 {"EndMediaEdits", (PyCFunction)MediaObj_EndMediaEdits, 1,
2276 "() -> None"},
2277 {"SetMediaDefaultDataRefIndex", (PyCFunction)MediaObj_SetMediaDefaultDataRefIndex, 1,
2278 "(short index) -> None"},
2279 {"GetMediaDataHandlerDescription", (PyCFunction)MediaObj_GetMediaDataHandlerDescription, 1,
2280 "(short index, Str255 creatorName) -> (OSType dhType, OSType creatorManufacturer)"},
2281 {"GetMediaDataHandler", (PyCFunction)MediaObj_GetMediaDataHandler, 1,
2282 "(short index) -> (DataHandler _rv)"},
2283 {"SetMediaDataHandler", (PyCFunction)MediaObj_SetMediaDataHandler, 1,
2284 "(short index, DataHandlerComponent dataHandler) -> None"},
2285 {"GetMediaSampleDescriptionCount", (PyCFunction)MediaObj_GetMediaSampleDescriptionCount, 1,
2286 "() -> (long _rv)"},
2287 {"GetMediaSampleDescription", (PyCFunction)MediaObj_GetMediaSampleDescription, 1,
2288 "(long index, SampleDescriptionHandle descH) -> None"},
2289 {"SetMediaSampleDescription", (PyCFunction)MediaObj_SetMediaSampleDescription, 1,
2290 "(long index, SampleDescriptionHandle descH) -> None"},
2291 {"GetMediaSampleCount", (PyCFunction)MediaObj_GetMediaSampleCount, 1,
2292 "() -> (long _rv)"},
2293 {"SampleNumToMediaTime", (PyCFunction)MediaObj_SampleNumToMediaTime, 1,
2294 "(long logicalSampleNum) -> (TimeValue sampleTime, TimeValue sampleDuration)"},
2295 {"MediaTimeToSampleNum", (PyCFunction)MediaObj_MediaTimeToSampleNum, 1,
2296 "(TimeValue time) -> (long sampleNum, TimeValue sampleTime, TimeValue sampleDuration)"},
2297 {"AddMediaSample", (PyCFunction)MediaObj_AddMediaSample, 1,
2298 "(Handle dataIn, long inOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)"},
2299 {"AddMediaSampleReference", (PyCFunction)MediaObj_AddMediaSampleReference, 1,
2300 "(long dataOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)"},
2301 {"GetMediaSample", (PyCFunction)MediaObj_GetMediaSample, 1,
2302 "(Handle dataOut, long maxSizeToGrow, TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)"},
2303 {"GetMediaSampleReference", (PyCFunction)MediaObj_GetMediaSampleReference, 1,
2304 "(TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long dataOffset, long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)"},
2305 {"SetMediaPreferredChunkSize", (PyCFunction)MediaObj_SetMediaPreferredChunkSize, 1,
2306 "(long maxChunkSize) -> None"},
2307 {"GetMediaPreferredChunkSize", (PyCFunction)MediaObj_GetMediaPreferredChunkSize, 1,
2308 "() -> (long maxChunkSize)"},
2309 {"SetMediaShadowSync", (PyCFunction)MediaObj_SetMediaShadowSync, 1,
2310 "(long frameDiffSampleNum, long syncSampleNum) -> None"},
2311 {"GetMediaShadowSync", (PyCFunction)MediaObj_GetMediaShadowSync, 1,
2312 "(long frameDiffSampleNum) -> (long syncSampleNum)"},
2313 {"GetMediaDataSize", (PyCFunction)MediaObj_GetMediaDataSize, 1,
2314 "(TimeValue startTime, TimeValue duration) -> (long _rv)"},
2315 {"GetMediaNextInterestingTime", (PyCFunction)MediaObj_GetMediaNextInterestingTime, 1,
2316 "(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
2317 {"GetMediaDataRef", (PyCFunction)MediaObj_GetMediaDataRef, 1,
2318 "(short index) -> (Handle dataRef, OSType dataRefType, long dataRefAttributes)"},
2319 {"SetMediaDataRef", (PyCFunction)MediaObj_SetMediaDataRef, 1,
2320 "(short index, Handle dataRef, OSType dataRefType) -> None"},
2321 {"SetMediaDataRefAttributes", (PyCFunction)MediaObj_SetMediaDataRefAttributes, 1,
2322 "(short index, long dataRefAttributes) -> None"},
2323 {"AddMediaDataRef", (PyCFunction)MediaObj_AddMediaDataRef, 1,
2324 "(Handle dataRef, OSType dataRefType) -> (short index)"},
2325 {"GetMediaDataRefCount", (PyCFunction)MediaObj_GetMediaDataRefCount, 1,
2326 "() -> (short count)"},
2327 {"SetMediaPlayHints", (PyCFunction)MediaObj_SetMediaPlayHints, 1,
2328 "(long flags, long flagsMask) -> None"},
2329 {NULL, NULL, 0}
2330 };
2331
2332 PyMethodChain MediaObj_chain = { MediaObj_methods, NULL };
2333
2334 static PyObject *MediaObj_getattr(self, name)
2335 MediaObject *self;
2336 char *name;
2337 {
2338 return Py_FindMethodInChain(&MediaObj_chain, (PyObject *)self, name);
2339 }
2340
2341 #define MediaObj_setattr NULL
2342
2343 PyTypeObject Media_Type = {
2344 PyObject_HEAD_INIT(&PyType_Type)
2345 0, /*ob_size*/
2346 "Media", /*tp_name*/
2347 sizeof(MediaObject), /*tp_basicsize*/
2348 0, /*tp_itemsize*/
2349 /* methods */
2350 (destructor) MediaObj_dealloc, /*tp_dealloc*/
2351 0, /*tp_print*/
2352 (getattrfunc) MediaObj_getattr, /*tp_getattr*/
2353 (setattrfunc) MediaObj_setattr, /*tp_setattr*/
2354 };
2355
2356 /* --------------------- End object type Media ---------------------- */
2357
2358
2359 /* ----------------------- Object type Track ------------------------ */
2360
2361 PyTypeObject Track_Type;
2362
2363 #define TrackObj_Check(x) ((x)->ob_type == &Track_Type)
2364
2365 typedef struct TrackObject {
2366 PyObject_HEAD
2367 Track ob_itself;
2368 } TrackObject;
2369
2370 PyObject *TrackObj_New(itself)
2371 Track itself;
2372 {
2373 TrackObject *it;
2374 if (itself == NULL) {
2375 PyErr_SetString(Qt_Error,"Cannot create null Track");
2376 return NULL;
2377 }
2378 it = PyObject_NEW(TrackObject, &Track_Type);
2379 if (it == NULL) return NULL;
2380 it->ob_itself = itself;
2381 return (PyObject *)it;
2382 }
2383 TrackObj_Convert(v, p_itself)
2384 PyObject *v;
2385 Track *p_itself;
2386 {
2387 if (!TrackObj_Check(v))
2388 {
2389 PyErr_SetString(PyExc_TypeError, "Track required");
2390 return 0;
2391 }
2392 *p_itself = ((TrackObject *)v)->ob_itself;
2393 return 1;
2394 }
2395
2396 static void TrackObj_dealloc(self)
2397 TrackObject *self;
2398 {
2399 DisposeMovieTrack(self->ob_itself);
2400 PyMem_DEL(self);
2401 }
2402
2403 static PyObject *TrackObj_LoadTrackIntoRam(_self, _args)
2404 TrackObject *_self;
2405 PyObject *_args;
2406 {
2407 PyObject *_res = NULL;
2408 OSErr _err;
2409 TimeValue time;
2410 TimeValue duration;
2411 long flags;
2412 if (!PyArg_ParseTuple(_args, "lll",
2413 &time,
2414 &duration,
2415 &flags))
2416 return NULL;
2417 _err = LoadTrackIntoRam(_self->ob_itself,
2418 time,
2419 duration,
2420 flags);
2421 if (_err != noErr) return PyMac_Error(_err);
2422 Py_INCREF(Py_None);
2423 _res = Py_None;
2424 return _res;
2425 }
2426
2427 static PyObject *TrackObj_GetTrackPict(_self, _args)
2428 TrackObject *_self;
2429 PyObject *_args;
2430 {
2431 PyObject *_res = NULL;
2432 PicHandle _rv;
2433 TimeValue time;
2434 if (!PyArg_ParseTuple(_args, "l",
2435 &time))
2436 return NULL;
2437 _rv = GetTrackPict(_self->ob_itself,
2438 time);
2439 _res = Py_BuildValue("O&",
2440 ResObj_New, _rv);
2441 return _res;
2442 }
2443
2444 static PyObject *TrackObj_GetTrackClipRgn(_self, _args)
2445 TrackObject *_self;
2446 PyObject *_args;
2447 {
2448 PyObject *_res = NULL;
2449 RgnHandle _rv;
2450 if (!PyArg_ParseTuple(_args, ""))
2451 return NULL;
2452 _rv = GetTrackClipRgn(_self->ob_itself);
2453 _res = Py_BuildValue("O&",
2454 ResObj_New, _rv);
2455 return _res;
2456 }
2457
2458 static PyObject *TrackObj_SetTrackClipRgn(_self, _args)
2459 TrackObject *_self;
2460 PyObject *_args;
2461 {
2462 PyObject *_res = NULL;
2463 RgnHandle theClip;
2464 if (!PyArg_ParseTuple(_args, "O&",
2465 ResObj_Convert, &theClip))
2466 return NULL;
2467 SetTrackClipRgn(_self->ob_itself,
2468 theClip);
2469 Py_INCREF(Py_None);
2470 _res = Py_None;
2471 return _res;
2472 }
2473
2474 static PyObject *TrackObj_GetTrackDisplayBoundsRgn(_self, _args)
2475 TrackObject *_self;
2476 PyObject *_args;
2477 {
2478 PyObject *_res = NULL;
2479 RgnHandle _rv;
2480 if (!PyArg_ParseTuple(_args, ""))
2481 return NULL;
2482 _rv = GetTrackDisplayBoundsRgn(_self->ob_itself);
2483 _res = Py_BuildValue("O&",
2484 ResObj_New, _rv);
2485 return _res;
2486 }
2487
2488 static PyObject *TrackObj_GetTrackMovieBoundsRgn(_self, _args)
2489 TrackObject *_self;
2490 PyObject *_args;
2491 {
2492 PyObject *_res = NULL;
2493 RgnHandle _rv;
2494 if (!PyArg_ParseTuple(_args, ""))
2495 return NULL;
2496 _rv = GetTrackMovieBoundsRgn(_self->ob_itself);
2497 _res = Py_BuildValue("O&",
2498 ResObj_New, _rv);
2499 return _res;
2500 }
2501
2502 static PyObject *TrackObj_GetTrackBoundsRgn(_self, _args)
2503 TrackObject *_self;
2504 PyObject *_args;
2505 {
2506 PyObject *_res = NULL;
2507 RgnHandle _rv;
2508 if (!PyArg_ParseTuple(_args, ""))
2509 return NULL;
2510 _rv = GetTrackBoundsRgn(_self->ob_itself);
2511 _res = Py_BuildValue("O&",
2512 ResObj_New, _rv);
2513 return _res;
2514 }
2515
2516 static PyObject *TrackObj_GetTrackMatte(_self, _args)
2517 TrackObject *_self;
2518 PyObject *_args;
2519 {
2520 PyObject *_res = NULL;
2521 PixMapHandle _rv;
2522 if (!PyArg_ParseTuple(_args, ""))
2523 return NULL;
2524 _rv = GetTrackMatte(_self->ob_itself);
2525 _res = Py_BuildValue("O&",
2526 ResObj_New, _rv);
2527 return _res;
2528 }
2529
2530 static PyObject *TrackObj_SetTrackMatte(_self, _args)
2531 TrackObject *_self;
2532 PyObject *_args;
2533 {
2534 PyObject *_res = NULL;
2535 PixMapHandle theMatte;
2536 if (!PyArg_ParseTuple(_args, "O&",
2537 ResObj_Convert, &theMatte))
2538 return NULL;
2539 SetTrackMatte(_self->ob_itself,
2540 theMatte);
2541 Py_INCREF(Py_None);
2542 _res = Py_None;
2543 return _res;
2544 }
2545
2546 static PyObject *TrackObj_GetTrackID(_self, _args)
2547 TrackObject *_self;
2548 PyObject *_args;
2549 {
2550 PyObject *_res = NULL;
2551 long _rv;
2552 if (!PyArg_ParseTuple(_args, ""))
2553 return NULL;
2554 _rv = GetTrackID(_self->ob_itself);
2555 _res = Py_BuildValue("l",
2556 _rv);
2557 return _res;
2558 }
2559
2560 static PyObject *TrackObj_GetTrackMovie(_self, _args)
2561 TrackObject *_self;
2562 PyObject *_args;
2563 {
2564 PyObject *_res = NULL;
2565 Movie _rv;
2566 if (!PyArg_ParseTuple(_args, ""))
2567 return NULL;
2568 _rv = GetTrackMovie(_self->ob_itself);
2569 _res = Py_BuildValue("O&",
2570 MovieObj_New, _rv);
2571 return _res;
2572 }
2573
2574 static PyObject *TrackObj_GetTrackEnabled(_self, _args)
2575 TrackObject *_self;
2576 PyObject *_args;
2577 {
2578 PyObject *_res = NULL;
2579 Boolean _rv;
2580 if (!PyArg_ParseTuple(_args, ""))
2581 return NULL;
2582 _rv = GetTrackEnabled(_self->ob_itself);
2583 _res = Py_BuildValue("b",
2584 _rv);
2585 return _res;
2586 }
2587
2588 static PyObject *TrackObj_SetTrackEnabled(_self, _args)
2589 TrackObject *_self;
2590 PyObject *_args;
2591 {
2592 PyObject *_res = NULL;
2593 Boolean isEnabled;
2594 if (!PyArg_ParseTuple(_args, "b",
2595 &isEnabled))
2596 return NULL;
2597 SetTrackEnabled(_self->ob_itself,
2598 isEnabled);
2599 Py_INCREF(Py_None);
2600 _res = Py_None;
2601 return _res;
2602 }
2603
2604 static PyObject *TrackObj_GetTrackUsage(_self, _args)
2605 TrackObject *_self;
2606 PyObject *_args;
2607 {
2608 PyObject *_res = NULL;
2609 long _rv;
2610 if (!PyArg_ParseTuple(_args, ""))
2611 return NULL;
2612 _rv = GetTrackUsage(_self->ob_itself);
2613 _res = Py_BuildValue("l",
2614 _rv);
2615 return _res;
2616 }
2617
2618 static PyObject *TrackObj_SetTrackUsage(_self, _args)
2619 TrackObject *_self;
2620 PyObject *_args;
2621 {
2622 PyObject *_res = NULL;
2623 long usage;
2624 if (!PyArg_ParseTuple(_args, "l",
2625 &usage))
2626 return NULL;
2627 SetTrackUsage(_self->ob_itself,
2628 usage);
2629 Py_INCREF(Py_None);
2630 _res = Py_None;
2631 return _res;
2632 }
2633
2634 static PyObject *TrackObj_GetTrackDuration(_self, _args)
2635 TrackObject *_self;
2636 PyObject *_args;
2637 {
2638 PyObject *_res = NULL;
2639 TimeValue _rv;
2640 if (!PyArg_ParseTuple(_args, ""))
2641 return NULL;
2642 _rv = GetTrackDuration(_self->ob_itself);
2643 _res = Py_BuildValue("l",
2644 _rv);
2645 return _res;
2646 }
2647
2648 static PyObject *TrackObj_GetTrackOffset(_self, _args)
2649 TrackObject *_self;
2650 PyObject *_args;
2651 {
2652 PyObject *_res = NULL;
2653 TimeValue _rv;
2654 if (!PyArg_ParseTuple(_args, ""))
2655 return NULL;
2656 _rv = GetTrackOffset(_self->ob_itself);
2657 _res = Py_BuildValue("l",
2658 _rv);
2659 return _res;
2660 }
2661
2662 static PyObject *TrackObj_SetTrackOffset(_self, _args)
2663 TrackObject *_self;
2664 PyObject *_args;
2665 {
2666 PyObject *_res = NULL;
2667 TimeValue movieOffsetTime;
2668 if (!PyArg_ParseTuple(_args, "l",
2669 &movieOffsetTime))
2670 return NULL;
2671 SetTrackOffset(_self->ob_itself,
2672 movieOffsetTime);
2673 Py_INCREF(Py_None);
2674 _res = Py_None;
2675 return _res;
2676 }
2677
2678 static PyObject *TrackObj_GetTrackLayer(_self, _args)
2679 TrackObject *_self;
2680 PyObject *_args;
2681 {
2682 PyObject *_res = NULL;
2683 short _rv;
2684 if (!PyArg_ParseTuple(_args, ""))
2685 return NULL;
2686 _rv = GetTrackLayer(_self->ob_itself);
2687 _res = Py_BuildValue("h",
2688 _rv);
2689 return _res;
2690 }
2691
2692 static PyObject *TrackObj_SetTrackLayer(_self, _args)
2693 TrackObject *_self;
2694 PyObject *_args;
2695 {
2696 PyObject *_res = NULL;
2697 short layer;
2698 if (!PyArg_ParseTuple(_args, "h",
2699 &layer))
2700 return NULL;
2701 SetTrackLayer(_self->ob_itself,
2702 layer);
2703 Py_INCREF(Py_None);
2704 _res = Py_None;
2705 return _res;
2706 }
2707
2708 static PyObject *TrackObj_GetTrackAlternate(_self, _args)
2709 TrackObject *_self;
2710 PyObject *_args;
2711 {
2712 PyObject *_res = NULL;
2713 Track _rv;
2714 if (!PyArg_ParseTuple(_args, ""))
2715 return NULL;
2716 _rv = GetTrackAlternate(_self->ob_itself);
2717 _res = Py_BuildValue("O&",
2718 TrackObj_New, _rv);
2719 return _res;
2720 }
2721
2722 static PyObject *TrackObj_SetTrackAlternate(_self, _args)
2723 TrackObject *_self;
2724 PyObject *_args;
2725 {
2726 PyObject *_res = NULL;
2727 Track alternateT;
2728 if (!PyArg_ParseTuple(_args, "O&",
2729 TrackObj_Convert, &alternateT))
2730 return NULL;
2731 SetTrackAlternate(_self->ob_itself,
2732 alternateT);
2733 Py_INCREF(Py_None);
2734 _res = Py_None;
2735 return _res;
2736 }
2737
2738 static PyObject *TrackObj_GetTrackVolume(_self, _args)
2739 TrackObject *_self;
2740 PyObject *_args;
2741 {
2742 PyObject *_res = NULL;
2743 short _rv;
2744 if (!PyArg_ParseTuple(_args, ""))
2745 return NULL;
2746 _rv = GetTrackVolume(_self->ob_itself);
2747 _res = Py_BuildValue("h",
2748 _rv);
2749 return _res;
2750 }
2751
2752 static PyObject *TrackObj_SetTrackVolume(_self, _args)
2753 TrackObject *_self;
2754 PyObject *_args;
2755 {
2756 PyObject *_res = NULL;
2757 short volume;
2758 if (!PyArg_ParseTuple(_args, "h",
2759 &volume))
2760 return NULL;
2761 SetTrackVolume(_self->ob_itself,
2762 volume);
2763 Py_INCREF(Py_None);
2764 _res = Py_None;
2765 return _res;
2766 }
2767
2768 static PyObject *TrackObj_GetTrackDimensions(_self, _args)
2769 TrackObject *_self;
2770 PyObject *_args;
2771 {
2772 PyObject *_res = NULL;
2773 Fixed width;
2774 Fixed height;
2775 if (!PyArg_ParseTuple(_args, ""))
2776 return NULL;
2777 GetTrackDimensions(_self->ob_itself,
2778 &width,
2779 &height);
2780 _res = Py_BuildValue("O&O&",
2781 PyMac_BuildFixed, width,
2782 PyMac_BuildFixed, height);
2783 return _res;
2784 }
2785
2786 static PyObject *TrackObj_SetTrackDimensions(_self, _args)
2787 TrackObject *_self;
2788 PyObject *_args;
2789 {
2790 PyObject *_res = NULL;
2791 Fixed width;
2792 Fixed height;
2793 if (!PyArg_ParseTuple(_args, "O&O&",
2794 PyMac_GetFixed, &width,
2795 PyMac_GetFixed, &height))
2796 return NULL;
2797 SetTrackDimensions(_self->ob_itself,
2798 width,
2799 height);
2800 Py_INCREF(Py_None);
2801 _res = Py_None;
2802 return _res;
2803 }
2804
2805 static PyObject *TrackObj_GetTrackUserData(_self, _args)
2806 TrackObject *_self;
2807 PyObject *_args;
2808 {
2809 PyObject *_res = NULL;
2810 UserData _rv;
2811 if (!PyArg_ParseTuple(_args, ""))
2812 return NULL;
2813 _rv = GetTrackUserData(_self->ob_itself);
2814 _res = Py_BuildValue("O&",
2815 UserDataObj_New, _rv);
2816 return _res;
2817 }
2818
2819 static PyObject *TrackObj_NewTrackMedia(_self, _args)
2820 TrackObject *_self;
2821 PyObject *_args;
2822 {
2823 PyObject *_res = NULL;
2824 Media _rv;
2825 OSType mediaType;
2826 TimeScale timeScale;
2827 Handle dataRef;
2828 OSType dataRefType;
2829 if (!PyArg_ParseTuple(_args, "O&lO&O&",
2830 PyMac_GetOSType, &mediaType,
2831 &timeScale,
2832 ResObj_Convert, &dataRef,
2833 PyMac_GetOSType, &dataRefType))
2834 return NULL;
2835 _rv = NewTrackMedia(_self->ob_itself,
2836 mediaType,
2837 timeScale,
2838 dataRef,
2839 dataRefType);
2840 _res = Py_BuildValue("O&",
2841 MediaObj_New, _rv);
2842 return _res;
2843 }
2844
2845 static PyObject *TrackObj_GetTrackMedia(_self, _args)
2846 TrackObject *_self;
2847 PyObject *_args;
2848 {
2849 PyObject *_res = NULL;
2850 Media _rv;
2851 if (!PyArg_ParseTuple(_args, ""))
2852 return NULL;
2853 _rv = GetTrackMedia(_self->ob_itself);
2854 _res = Py_BuildValue("O&",
2855 MediaObj_New, _rv);
2856 return _res;
2857 }
2858
2859 static PyObject *TrackObj_InsertMediaIntoTrack(_self, _args)
2860 TrackObject *_self;
2861 PyObject *_args;
2862 {
2863 PyObject *_res = NULL;
2864 OSErr _err;
2865 TimeValue trackStart;
2866 TimeValue mediaTime;
2867 TimeValue mediaDuration;
2868 Fixed mediaRate;
2869 if (!PyArg_ParseTuple(_args, "lllO&",
2870 &trackStart,
2871 &mediaTime,
2872 &mediaDuration,
2873 PyMac_GetFixed, &mediaRate))
2874 return NULL;
2875 _err = InsertMediaIntoTrack(_self->ob_itself,
2876 trackStart,
2877 mediaTime,
2878 mediaDuration,
2879 mediaRate);
2880 if (_err != noErr) return PyMac_Error(_err);
2881 Py_INCREF(Py_None);
2882 _res = Py_None;
2883 return _res;
2884 }
2885
2886 static PyObject *TrackObj_InsertTrackSegment(_self, _args)
2887 TrackObject *_self;
2888 PyObject *_args;
2889 {
2890 PyObject *_res = NULL;
2891 OSErr _err;
2892 Track dstTrack;
2893 TimeValue srcIn;
2894 TimeValue srcDuration;
2895 TimeValue dstIn;
2896 if (!PyArg_ParseTuple(_args, "O&lll",
2897 TrackObj_Convert, &dstTrack,
2898 &srcIn,
2899 &srcDuration,
2900 &dstIn))
2901 return NULL;
2902 _err = InsertTrackSegment(_self->ob_itself,
2903 dstTrack,
2904 srcIn,
2905 srcDuration,
2906 dstIn);
2907 if (_err != noErr) return PyMac_Error(_err);
2908 Py_INCREF(Py_None);
2909 _res = Py_None;
2910 return _res;
2911 }
2912
2913 static PyObject *TrackObj_InsertEmptyTrackSegment(_self, _args)
2914 TrackObject *_self;
2915 PyObject *_args;
2916 {
2917 PyObject *_res = NULL;
2918 OSErr _err;
2919 TimeValue dstIn;
2920 TimeValue dstDuration;
2921 if (!PyArg_ParseTuple(_args, "ll",
2922 &dstIn,
2923 &dstDuration))
2924 return NULL;
2925 _err = InsertEmptyTrackSegment(_self->ob_itself,
2926 dstIn,
2927 dstDuration);
2928 if (_err != noErr) return PyMac_Error(_err);
2929 Py_INCREF(Py_None);
2930 _res = Py_None;
2931 return _res;
2932 }
2933
2934 static PyObject *TrackObj_DeleteTrackSegment(_self, _args)
2935 TrackObject *_self;
2936 PyObject *_args;
2937 {
2938 PyObject *_res = NULL;
2939 OSErr _err;
2940 TimeValue startTime;
2941 TimeValue duration;
2942 if (!PyArg_ParseTuple(_args, "ll",
2943 &startTime,
2944 &duration))
2945 return NULL;
2946 _err = DeleteTrackSegment(_self->ob_itself,
2947 startTime,
2948 duration);
2949 if (_err != noErr) return PyMac_Error(_err);
2950 Py_INCREF(Py_None);
2951 _res = Py_None;
2952 return _res;
2953 }
2954
2955 static PyObject *TrackObj_ScaleTrackSegment(_self, _args)
2956 TrackObject *_self;
2957 PyObject *_args;
2958 {
2959 PyObject *_res = NULL;
2960 OSErr _err;
2961 TimeValue startTime;
2962 TimeValue oldDuration;
2963 TimeValue newDuration;
2964 if (!PyArg_ParseTuple(_args, "lll",
2965 &startTime,
2966 &oldDuration,
2967 &newDuration))
2968 return NULL;
2969 _err = ScaleTrackSegment(_self->ob_itself,
2970 startTime,
2971 oldDuration,
2972 newDuration);
2973 if (_err != noErr) return PyMac_Error(_err);
2974 Py_INCREF(Py_None);
2975 _res = Py_None;
2976 return _res;
2977 }
2978
2979 static PyObject *TrackObj_IsScrapMovie(_self, _args)
2980 TrackObject *_self;
2981 PyObject *_args;
2982 {
2983 PyObject *_res = NULL;
2984 Component _rv;
2985 if (!PyArg_ParseTuple(_args, ""))
2986 return NULL;
2987 _rv = IsScrapMovie(_self->ob_itself);
2988 _res = Py_BuildValue("O&",
2989 CmpObj_New, _rv);
2990 return _res;
2991 }
2992
2993 static PyObject *TrackObj_CopyTrackSettings(_self, _args)
2994 TrackObject *_self;
2995 PyObject *_args;
2996 {
2997 PyObject *_res = NULL;
2998 OSErr _err;
2999 Track dstTrack;
3000 if (!PyArg_ParseTuple(_args, "O&",
3001 TrackObj_Convert, &dstTrack))
3002 return NULL;
3003 _err = CopyTrackSettings(_self->ob_itself,
3004 dstTrack);
3005 if (_err != noErr) return PyMac_Error(_err);
3006 Py_INCREF(Py_None);
3007 _res = Py_None;
3008 return _res;
3009 }
3010
3011 static PyObject *TrackObj_AddEmptyTrackToMovie(_self, _args)
3012 TrackObject *_self;
3013 PyObject *_args;
3014 {
3015 PyObject *_res = NULL;
3016 OSErr _err;
3017 Movie dstMovie;
3018 Handle dataRef;
3019 OSType dataRefType;
3020 Track dstTrack;
3021 if (!PyArg_ParseTuple(_args, "O&O&O&",
3022 MovieObj_Convert, &dstMovie,
3023 ResObj_Convert, &dataRef,
3024 PyMac_GetOSType, &dataRefType))
3025 return NULL;
3026 _err = AddEmptyTrackToMovie(_self->ob_itself,
3027 dstMovie,
3028 dataRef,
3029 dataRefType,
3030 &dstTrack);
3031 if (_err != noErr) return PyMac_Error(_err);
3032 _res = Py_BuildValue("O&",
3033 TrackObj_New, dstTrack);
3034 return _res;
3035 }
3036
3037 static PyObject *TrackObj_AddTrackReference(_self, _args)
3038 TrackObject *_self;
3039 PyObject *_args;
3040 {
3041 PyObject *_res = NULL;
3042 OSErr _err;
3043 Track refTrack;
3044 OSType refType;
3045 long addedIndex;
3046 if (!PyArg_ParseTuple(_args, "O&O&",
3047 TrackObj_Convert, &refTrack,
3048 PyMac_GetOSType, &refType))
3049 return NULL;
3050 _err = AddTrackReference(_self->ob_itself,
3051 refTrack,
3052 refType,
3053 &addedIndex);
3054 if (_err != noErr) return PyMac_Error(_err);
3055 _res = Py_BuildValue("l",
3056 addedIndex);
3057 return _res;
3058 }
3059
3060 static PyObject *TrackObj_DeleteTrackReference(_self, _args)
3061 TrackObject *_self;
3062 PyObject *_args;
3063 {
3064 PyObject *_res = NULL;
3065 OSErr _err;
3066 OSType refType;
3067 long index;
3068 if (!PyArg_ParseTuple(_args, "O&l",
3069 PyMac_GetOSType, &refType,
3070 &index))
3071 return NULL;
3072 _err = DeleteTrackReference(_self->ob_itself,
3073 refType,
3074 index);
3075 if (_err != noErr) return PyMac_Error(_err);
3076 Py_INCREF(Py_None);
3077 _res = Py_None;
3078 return _res;
3079 }
3080
3081 static PyObject *TrackObj_SetTrackReference(_self, _args)
3082 TrackObject *_self;
3083 PyObject *_args;
3084 {
3085 PyObject *_res = NULL;
3086 OSErr _err;
3087 Track refTrack;
3088 OSType refType;
3089 long index;
3090 if (!PyArg_ParseTuple(_args, "O&O&l",
3091 TrackObj_Convert, &refTrack,
3092 PyMac_GetOSType, &refType,
3093 &index))
3094 return NULL;
3095 _err = SetTrackReference(_self->ob_itself,
3096 refTrack,
3097 refType,
3098 index);
3099 if (_err != noErr) return PyMac_Error(_err);
3100 Py_INCREF(Py_None);
3101 _res = Py_None;
3102 return _res;
3103 }
3104
3105 static PyObject *TrackObj_GetTrackReference(_self, _args)
3106 TrackObject *_self;
3107 PyObject *_args;
3108 {
3109 PyObject *_res = NULL;
3110 Track _rv;
3111 OSType refType;
3112 long index;
3113 if (!PyArg_ParseTuple(_args, "O&l",
3114 PyMac_GetOSType, &refType,
3115 &index))
3116 return NULL;
3117 _rv = GetTrackReference(_self->ob_itself,
3118 refType,
3119 index);
3120 _res = Py_BuildValue("O&",
3121 TrackObj_New, _rv);
3122 return _res;
3123 }
3124
3125 static PyObject *TrackObj_GetNextTrackReferenceType(_self, _args)
3126 TrackObject *_self;
3127 PyObject *_args;
3128 {
3129 PyObject *_res = NULL;
3130 OSType _rv;
3131 OSType refType;
3132 if (!PyArg_ParseTuple(_args, "O&",
3133 PyMac_GetOSType, &refType))
3134 return NULL;
3135 _rv = GetNextTrackReferenceType(_self->ob_itself,
3136 refType);
3137 _res = Py_BuildValue("O&",
3138 PyMac_BuildOSType, _rv);
3139 return _res;
3140 }
3141
3142 static PyObject *TrackObj_GetTrackReferenceCount(_self, _args)
3143 TrackObject *_self;
3144 PyObject *_args;
3145 {
3146 PyObject *_res = NULL;
3147 long _rv;
3148 OSType refType;
3149 if (!PyArg_ParseTuple(_args, "O&",
3150 PyMac_GetOSType, &refType))
3151 return NULL;
3152 _rv = GetTrackReferenceCount(_self->ob_itself,
3153 refType);
3154 _res = Py_BuildValue("l",
3155 _rv);
3156 return _res;
3157 }
3158
3159 static PyObject *TrackObj_GetTrackEditRate(_self, _args)
3160 TrackObject *_self;
3161 PyObject *_args;
3162 {
3163 PyObject *_res = NULL;
3164 Fixed _rv;
3165 TimeValue atTime;
3166 if (!PyArg_ParseTuple(_args, "l",
3167 &atTime))
3168 return NULL;
3169 _rv = GetTrackEditRate(_self->ob_itself,
3170 atTime);
3171 _res = Py_BuildValue("O&",
3172 PyMac_BuildFixed, _rv);
3173 return _res;
3174 }
3175
3176 static PyObject *TrackObj_GetTrackDataSize(_self, _args)
3177 TrackObject *_self;
3178 PyObject *_args;
3179 {
3180 PyObject *_res = NULL;
3181 long _rv;
3182 TimeValue startTime;
3183 TimeValue duration;
3184 if (!PyArg_ParseTuple(_args, "ll",
3185 &startTime,
3186 &duration))
3187 return NULL;
3188 _rv = GetTrackDataSize(_self->ob_itself,
3189 startTime,
3190 duration);
3191 _res = Py_BuildValue("l",
3192 _rv);
3193 return _res;
3194 }
3195
3196 static PyObject *TrackObj_PtInTrack(_self, _args)
3197 TrackObject *_self;
3198 PyObject *_args;
3199 {
3200 PyObject *_res = NULL;
3201 Boolean _rv;
3202 Point pt;
3203 if (!PyArg_ParseTuple(_args, "O&",
3204 PyMac_GetPoint, &pt))
3205 return NULL;
3206 _rv = PtInTrack(_self->ob_itself,
3207 pt);
3208 _res = Py_BuildValue("b",
3209 _rv);
3210 return _res;
3211 }
3212
3213 static PyObject *TrackObj_GetTrackNextInterestingTime(_self, _args)
3214 TrackObject *_self;
3215 PyObject *_args;
3216 {
3217 PyObject *_res = NULL;
3218 short interestingTimeFlags;
3219 TimeValue time;
3220 Fixed rate;
3221 TimeValue interestingTime;
3222 TimeValue interestingDuration;
3223 if (!PyArg_ParseTuple(_args, "hlO&",
3224 &interestingTimeFlags,
3225 &time,
3226 PyMac_GetFixed, &rate))
3227 return NULL;
3228 GetTrackNextInterestingTime(_self->ob_itself,
3229 interestingTimeFlags,
3230 time,
3231 rate,
3232 &interestingTime,
3233 &interestingDuration);
3234 _res = Py_BuildValue("ll",
3235 interestingTime,
3236 interestingDuration);
3237 return _res;
3238 }
3239
3240 static PyObject *TrackObj_GetTrackSegmentDisplayBoundsRgn(_self, _args)
3241 TrackObject *_self;
3242 PyObject *_args;
3243 {
3244 PyObject *_res = NULL;
3245 RgnHandle _rv;
3246 TimeValue time;
3247 TimeValue duration;
3248 if (!PyArg_ParseTuple(_args, "ll",
3249 &time,
3250 &duration))
3251 return NULL;
3252 _rv = GetTrackSegmentDisplayBoundsRgn(_self->ob_itself,
3253 time,
3254 duration);
3255 _res = Py_BuildValue("O&",
3256 ResObj_New, _rv);
3257 return _res;
3258 }
3259
3260 static PyObject *TrackObj_GetTrackStatus(_self, _args)
3261 TrackObject *_self;
3262 PyObject *_args;
3263 {
3264 PyObject *_res = NULL;
3265 ComponentResult _rv;
3266 if (!PyArg_ParseTuple(_args, ""))
3267 return NULL;
3268 _rv = GetTrackStatus(_self->ob_itself);
3269 _res = Py_BuildValue("l",
3270 _rv);
3271 return _res;
3272 }
3273
3274 static PyObject *TrackObj_SetTrackLoadSettings(_self, _args)
3275 TrackObject *_self;
3276 PyObject *_args;
3277 {
3278 PyObject *_res = NULL;
3279 TimeValue preloadTime;
3280 TimeValue preloadDuration;
3281 long preloadFlags;
3282 long defaultHints;
3283 if (!PyArg_ParseTuple(_args, "llll",
3284 &preloadTime,
3285 &preloadDuration,
3286 &preloadFlags,
3287 &defaultHints))
3288 return NULL;
3289 SetTrackLoadSettings(_self->ob_itself,
3290 preloadTime,
3291 preloadDuration,
3292 preloadFlags,
3293 defaultHints);
3294 Py_INCREF(Py_None);
3295 _res = Py_None;
3296 return _res;
3297 }
3298
3299 static PyObject *TrackObj_GetTrackLoadSettings(_self, _args)
3300 TrackObject *_self;
3301 PyObject *_args;
3302 {
3303 PyObject *_res = NULL;
3304 TimeValue preloadTime;
3305 TimeValue preloadDuration;
3306 long preloadFlags;
3307 long defaultHints;
3308 if (!PyArg_ParseTuple(_args, ""))
3309 return NULL;
3310 GetTrackLoadSettings(_self->ob_itself,
3311 &preloadTime,
3312 &preloadDuration,
3313 &preloadFlags,
3314 &defaultHints);
3315 _res = Py_BuildValue("llll",
3316 preloadTime,
3317 preloadDuration,
3318 preloadFlags,
3319 defaultHints);
3320 return _res;
3321 }
3322
3323 static PyMethodDef TrackObj_methods[] = {
3324 {"LoadTrackIntoRam", (PyCFunction)TrackObj_LoadTrackIntoRam, 1,
3325 "(TimeValue time, TimeValue duration, long flags) -> None"},
3326 {"GetTrackPict", (PyCFunction)TrackObj_GetTrackPict, 1,
3327 "(TimeValue time) -> (PicHandle _rv)"},
3328 {"GetTrackClipRgn", (PyCFunction)TrackObj_GetTrackClipRgn, 1,
3329 "() -> (RgnHandle _rv)"},
3330 {"SetTrackClipRgn", (PyCFunction)TrackObj_SetTrackClipRgn, 1,
3331 "(RgnHandle theClip) -> None"},
3332 {"GetTrackDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackDisplayBoundsRgn, 1,
3333 "() -> (RgnHandle _rv)"},
3334 {"GetTrackMovieBoundsRgn", (PyCFunction)TrackObj_GetTrackMovieBoundsRgn, 1,
3335 "() -> (RgnHandle _rv)"},
3336 {"GetTrackBoundsRgn", (PyCFunction)TrackObj_GetTrackBoundsRgn, 1,
3337 "() -> (RgnHandle _rv)"},
3338 {"GetTrackMatte", (PyCFunction)TrackObj_GetTrackMatte, 1,
3339 "() -> (PixMapHandle _rv)"},
3340 {"SetTrackMatte", (PyCFunction)TrackObj_SetTrackMatte, 1,
3341 "(PixMapHandle theMatte) -> None"},
3342 {"GetTrackID", (PyCFunction)TrackObj_GetTrackID, 1,
3343 "() -> (long _rv)"},
3344 {"GetTrackMovie", (PyCFunction)TrackObj_GetTrackMovie, 1,
3345 "() -> (Movie _rv)"},
3346 {"GetTrackEnabled", (PyCFunction)TrackObj_GetTrackEnabled, 1,
3347 "() -> (Boolean _rv)"},
3348 {"SetTrackEnabled", (PyCFunction)TrackObj_SetTrackEnabled, 1,
3349 "(Boolean isEnabled) -> None"},
3350 {"GetTrackUsage", (PyCFunction)TrackObj_GetTrackUsage, 1,
3351 "() -> (long _rv)"},
3352 {"SetTrackUsage", (PyCFunction)TrackObj_SetTrackUsage, 1,
3353 "(long usage) -> None"},
3354 {"GetTrackDuration", (PyCFunction)TrackObj_GetTrackDuration, 1,
3355 "() -> (TimeValue _rv)"},
3356 {"GetTrackOffset", (PyCFunction)TrackObj_GetTrackOffset, 1,
3357 "() -> (TimeValue _rv)"},
3358 {"SetTrackOffset", (PyCFunction)TrackObj_SetTrackOffset, 1,
3359 "(TimeValue movieOffsetTime) -> None"},
3360 {"GetTrackLayer", (PyCFunction)TrackObj_GetTrackLayer, 1,
3361 "() -> (short _rv)"},
3362 {"SetTrackLayer", (PyCFunction)TrackObj_SetTrackLayer, 1,
3363 "(short layer) -> None"},
3364 {"GetTrackAlternate", (PyCFunction)TrackObj_GetTrackAlternate, 1,
3365 "() -> (Track _rv)"},
3366 {"SetTrackAlternate", (PyCFunction)TrackObj_SetTrackAlternate, 1,
3367 "(Track alternateT) -> None"},
3368 {"GetTrackVolume", (PyCFunction)TrackObj_GetTrackVolume, 1,
3369 "() -> (short _rv)"},
3370 {"SetTrackVolume", (PyCFunction)TrackObj_SetTrackVolume, 1,
3371 "(short volume) -> None"},
3372 {"GetTrackDimensions", (PyCFunction)TrackObj_GetTrackDimensions, 1,
3373 "() -> (Fixed width, Fixed height)"},
3374 {"SetTrackDimensions", (PyCFunction)TrackObj_SetTrackDimensions, 1,
3375 "(Fixed width, Fixed height) -> None"},
3376 {"GetTrackUserData", (PyCFunction)TrackObj_GetTrackUserData, 1,
3377 "() -> (UserData _rv)"},
3378 {"NewTrackMedia", (PyCFunction)TrackObj_NewTrackMedia, 1,
3379 "(OSType mediaType, TimeScale timeScale, Handle dataRef, OSType dataRefType) -> (Media _rv)"},
3380 {"GetTrackMedia", (PyCFunction)TrackObj_GetTrackMedia, 1,
3381 "() -> (Media _rv)"},
3382 {"InsertMediaIntoTrack", (PyCFunction)TrackObj_InsertMediaIntoTrack, 1,
3383 "(TimeValue trackStart, TimeValue mediaTime, TimeValue mediaDuration, Fixed mediaRate) -> None"},
3384 {"InsertTrackSegment", (PyCFunction)TrackObj_InsertTrackSegment, 1,
3385 "(Track dstTrack, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None"},
3386 {"InsertEmptyTrackSegment", (PyCFunction)TrackObj_InsertEmptyTrackSegment, 1,
3387 "(TimeValue dstIn, TimeValue dstDuration) -> None"},
3388 {"DeleteTrackSegment", (PyCFunction)TrackObj_DeleteTrackSegment, 1,
3389 "(TimeValue startTime, TimeValue duration) -> None"},
3390 {"ScaleTrackSegment", (PyCFunction)TrackObj_ScaleTrackSegment, 1,
3391 "(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None"},
3392 {"IsScrapMovie", (PyCFunction)TrackObj_IsScrapMovie, 1,
3393 "() -> (Component _rv)"},
3394 {"CopyTrackSettings", (PyCFunction)TrackObj_CopyTrackSettings, 1,
3395 "(Track dstTrack) -> None"},
3396 {"AddEmptyTrackToMovie", (PyCFunction)TrackObj_AddEmptyTrackToMovie, 1,
3397 "(Movie dstMovie, Handle dataRef, OSType dataRefType) -> (Track dstTrack)"},
3398 {"AddTrackReference", (PyCFunction)TrackObj_AddTrackReference, 1,
3399 "(Track refTrack, OSType refType) -> (long addedIndex)"},
3400 {"DeleteTrackReference", (PyCFunction)TrackObj_DeleteTrackReference, 1,
3401 "(OSType refType, long index) -> None"},
3402 {"SetTrackReference", (PyCFunction)TrackObj_SetTrackReference, 1,
3403 "(Track refTrack, OSType refType, long index) -> None"},
3404 {"GetTrackReference", (PyCFunction)TrackObj_GetTrackReference, 1,
3405 "(OSType refType, long index) -> (Track _rv)"},
3406 {"GetNextTrackReferenceType", (PyCFunction)TrackObj_GetNextTrackReferenceType, 1,
3407 "(OSType refType) -> (OSType _rv)"},
3408 {"GetTrackReferenceCount", (PyCFunction)TrackObj_GetTrackReferenceCount, 1,
3409 "(OSType refType) -> (long _rv)"},
3410 {"GetTrackEditRate", (PyCFunction)TrackObj_GetTrackEditRate, 1,
3411 "(TimeValue atTime) -> (Fixed _rv)"},
3412 {"GetTrackDataSize", (PyCFunction)TrackObj_GetTrackDataSize, 1,
3413 "(TimeValue startTime, TimeValue duration) -> (long _rv)"},
3414 {"PtInTrack", (PyCFunction)TrackObj_PtInTrack, 1,
3415 "(Point pt) -> (Boolean _rv)"},
3416 {"GetTrackNextInterestingTime", (PyCFunction)TrackObj_GetTrackNextInterestingTime, 1,
3417 "(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
3418 {"GetTrackSegmentDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackSegmentDisplayBoundsRgn, 1,
3419 "(TimeValue time, TimeValue duration) -> (RgnHandle _rv)"},
3420 {"GetTrackStatus", (PyCFunction)TrackObj_GetTrackStatus, 1,
3421 "() -> (ComponentResult _rv)"},
3422 {"SetTrackLoadSettings", (PyCFunction)TrackObj_SetTrackLoadSettings, 1,
3423 "(TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints) -> None"},
3424 {"GetTrackLoadSettings", (PyCFunction)TrackObj_GetTrackLoadSettings, 1,
3425 "() -> (TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints)"},
3426 {NULL, NULL, 0}
3427 };
3428
3429 PyMethodChain TrackObj_chain = { TrackObj_methods, NULL };
3430
3431 static PyObject *TrackObj_getattr(self, name)
3432 TrackObject *self;
3433 char *name;
3434 {
3435 return Py_FindMethodInChain(&TrackObj_chain, (PyObject *)self, name);
3436 }
3437
3438 #define TrackObj_setattr NULL
3439
3440 PyTypeObject Track_Type = {
3441 PyObject_HEAD_INIT(&PyType_Type)
3442 0, /*ob_size*/
3443 "Track", /*tp_name*/
3444 sizeof(TrackObject), /*tp_basicsize*/
3445 0, /*tp_itemsize*/
3446 /* methods */
3447 (destructor) TrackObj_dealloc, /*tp_dealloc*/
3448 0, /*tp_print*/
3449 (getattrfunc) TrackObj_getattr, /*tp_getattr*/
3450 (setattrfunc) TrackObj_setattr, /*tp_setattr*/
3451 };
3452
3453 /* --------------------- End object type Track ---------------------- */
3454
3455
3456 /* ----------------------- Object type Movie ------------------------ */
3457
3458 PyTypeObject Movie_Type;
3459
3460 #define MovieObj_Check(x) ((x)->ob_type == &Movie_Type)
3461
3462 typedef struct MovieObject {
3463 PyObject_HEAD
3464 Movie ob_itself;
3465 } MovieObject;
3466
3467 PyObject *MovieObj_New(itself)
3468 Movie itself;
3469 {
3470 MovieObject *it;
3471 if (itself == NULL) {
3472 PyErr_SetString(Qt_Error,"Cannot create null Movie");
3473 return NULL;
3474 }
3475 it = PyObject_NEW(MovieObject, &Movie_Type);
3476 if (it == NULL) return NULL;
3477 it->ob_itself = itself;
3478 return (PyObject *)it;
3479 }
3480 MovieObj_Convert(v, p_itself)
3481 PyObject *v;
3482 Movie *p_itself;
3483 {
3484 if (!MovieObj_Check(v))
3485 {
3486 PyErr_SetString(PyExc_TypeError, "Movie required");
3487 return 0;
3488 }
3489 *p_itself = ((MovieObject *)v)->ob_itself;
3490 return 1;
3491 }
3492
3493 static void MovieObj_dealloc(self)
3494 MovieObject *self;
3495 {
3496 DisposeMovie(self->ob_itself);
3497 PyMem_DEL(self);
3498 }
3499
3500 static PyObject *MovieObj_MoviesTask(_self, _args)
3501 MovieObject *_self;
3502 PyObject *_args;
3503 {
3504 PyObject *_res = NULL;
3505 long maxMilliSecToUse;
3506 if (!PyArg_ParseTuple(_args, "l",
3507 &maxMilliSecToUse))
3508 return NULL;
3509 MoviesTask(_self->ob_itself,
3510 maxMilliSecToUse);
3511 Py_INCREF(Py_None);
3512 _res = Py_None;
3513 return _res;
3514 }
3515
3516 static PyObject *MovieObj_PrerollMovie(_self, _args)
3517 MovieObject *_self;
3518 PyObject *_args;
3519 {
3520 PyObject *_res = NULL;
3521 OSErr _err;
3522 TimeValue time;
3523 Fixed Rate;
3524 if (!PyArg_ParseTuple(_args, "lO&",
3525 &time,
3526 PyMac_GetFixed, &Rate))
3527 return NULL;
3528 _err = PrerollMovie(_self->ob_itself,
3529 time,
3530 Rate);
3531 if (_err != noErr) return PyMac_Error(_err);
3532 Py_INCREF(Py_None);
3533 _res = Py_None;
3534 return _res;
3535 }
3536
3537 static PyObject *MovieObj_LoadMovieIntoRam(_self, _args)
3538 MovieObject *_self;
3539 PyObject *_args;
3540 {
3541 PyObject *_res = NULL;
3542 OSErr _err;
3543 TimeValue time;
3544 TimeValue duration;
3545 long flags;
3546 if (!PyArg_ParseTuple(_args, "lll",
3547 &time,
3548 &duration,
3549 &flags))
3550 return NULL;
3551 _err = LoadMovieIntoRam(_self->ob_itself,
3552 time,
3553 duration,
3554 flags);
3555 if (_err != noErr) return PyMac_Error(_err);
3556 Py_INCREF(Py_None);
3557 _res = Py_None;
3558 return _res;
3559 }
3560
3561 static PyObject *MovieObj_SetMovieActive(_self, _args)
3562 MovieObject *_self;
3563 PyObject *_args;
3564 {
3565 PyObject *_res = NULL;
3566 Boolean active;
3567 if (!PyArg_ParseTuple(_args, "b",
3568 &active))
3569 return NULL;
3570 SetMovieActive(_self->ob_itself,
3571 active);
3572 Py_INCREF(Py_None);
3573 _res = Py_None;
3574 return _res;
3575 }
3576
3577 static PyObject *MovieObj_GetMovieActive(_self, _args)
3578 MovieObject *_self;
3579 PyObject *_args;
3580 {
3581 PyObject *_res = NULL;
3582 Boolean _rv;
3583 if (!PyArg_ParseTuple(_args, ""))
3584 return NULL;
3585 _rv = GetMovieActive(_self->ob_itself);
3586 _res = Py_BuildValue("b",
3587 _rv);
3588 return _res;
3589 }
3590
3591 static PyObject *MovieObj_StartMovie(_self, _args)
3592 MovieObject *_self;
3593 PyObject *_args;
3594 {
3595 PyObject *_res = NULL;
3596 if (!PyArg_ParseTuple(_args, ""))
3597 return NULL;
3598 StartMovie(_self->ob_itself);
3599 Py_INCREF(Py_None);
3600 _res = Py_None;
3601 return _res;
3602 }
3603
3604 static PyObject *MovieObj_StopMovie(_self, _args)
3605 MovieObject *_self;
3606 PyObject *_args;
3607 {
3608 PyObject *_res = NULL;
3609 if (!PyArg_ParseTuple(_args, ""))
3610 return NULL;
3611 StopMovie(_self->ob_itself);
3612 Py_INCREF(Py_None);
3613 _res = Py_None;
3614 return _res;
3615 }
3616
3617 static PyObject *MovieObj_GoToBeginningOfMovie(_self, _args)
3618 MovieObject *_self;
3619 PyObject *_args;
3620 {
3621 PyObject *_res = NULL;
3622 if (!PyArg_ParseTuple(_args, ""))
3623 return NULL;
3624 GoToBeginningOfMovie(_self->ob_itself);
3625 Py_INCREF(Py_None);
3626 _res = Py_None;
3627 return _res;
3628 }
3629
3630 static PyObject *MovieObj_GoToEndOfMovie(_self, _args)
3631 MovieObject *_self;
3632 PyObject *_args;
3633 {
3634 PyObject *_res = NULL;
3635 if (!PyArg_ParseTuple(_args, ""))
3636 return NULL;
3637 GoToEndOfMovie(_self->ob_itself);
3638 Py_INCREF(Py_None);
3639 _res = Py_None;
3640 return _res;
3641 }
3642
3643 static PyObject *MovieObj_IsMovieDone(_self, _args)
3644 MovieObject *_self;
3645 PyObject *_args;
3646 {
3647 PyObject *_res = NULL;
3648 Boolean _rv;
3649 if (!PyArg_ParseTuple(_args, ""))
3650 return NULL;
3651 _rv = IsMovieDone(_self->ob_itself);
3652 _res = Py_BuildValue("b",
3653 _rv);
3654 return _res;
3655 }
3656
3657 static PyObject *MovieObj_GetMoviePreviewMode(_self, _args)
3658 MovieObject *_self;
3659 PyObject *_args;
3660 {
3661 PyObject *_res = NULL;
3662 Boolean _rv;
3663 if (!PyArg_ParseTuple(_args, ""))
3664 return NULL;
3665 _rv = GetMoviePreviewMode(_self->ob_itself);
3666 _res = Py_BuildValue("b",
3667 _rv);
3668 return _res;
3669 }
3670
3671 static PyObject *MovieObj_SetMoviePreviewMode(_self, _args)
3672 MovieObject *_self;
3673 PyObject *_args;
3674 {
3675 PyObject *_res = NULL;
3676 Boolean usePreview;
3677 if (!PyArg_ParseTuple(_args, "b",
3678 &usePreview))
3679 return NULL;
3680 SetMoviePreviewMode(_self->ob_itself,
3681 usePreview);
3682 Py_INCREF(Py_None);
3683 _res = Py_None;
3684 return _res;
3685 }
3686
3687 static PyObject *MovieObj_ShowMoviePoster(_self, _args)
3688 MovieObject *_self;
3689 PyObject *_args;
3690 {
3691 PyObject *_res = NULL;
3692 if (!PyArg_ParseTuple(_args, ""))
3693 return NULL;
3694 ShowMoviePoster(_self->ob_itself);
3695 Py_INCREF(Py_None);
3696 _res = Py_None;
3697 return _res;
3698 }
3699
3700 static PyObject *MovieObj_GetMovieTimeBase(_self, _args)
3701 MovieObject *_self;
3702 PyObject *_args;
3703 {
3704 PyObject *_res = NULL;
3705 TimeBase _rv;
3706 if (!PyArg_ParseTuple(_args, ""))
3707 return NULL;
3708 _rv = GetMovieTimeBase(_self->ob_itself);
3709 _res = Py_BuildValue("O&",
3710 TimeBaseObj_New, _rv);
3711 return _res;
3712 }
3713
3714 static PyObject *MovieObj_GetNextTrackForCompositing(_self, _args)
3715 MovieObject *_self;
3716 PyObject *_args;
3717 {
3718 PyObject *_res = NULL;
3719 Track _rv;
3720 Track theTrack;
3721 if (!PyArg_ParseTuple(_args, "O&",
3722 TrackObj_Convert, &theTrack))
3723 return NULL;
3724 _rv = GetNextTrackForCompositing(_self->ob_itself,
3725 theTrack);
3726 _res = Py_BuildValue("O&",
3727 TrackObj_New, _rv);
3728 return _res;
3729 }
3730
3731 static PyObject *MovieObj_GetPrevTrackForCompositing(_self, _args)
3732 MovieObject *_self;
3733 PyObject *_args;
3734 {
3735 PyObject *_res = NULL;
3736 Track _rv;
3737 Track theTrack;
3738 if (!PyArg_ParseTuple(_args, "O&",
3739 TrackObj_Convert, &theTrack))
3740 return NULL;
3741 _rv = GetPrevTrackForCompositing(_self->ob_itself,
3742 theTrack);
3743 _res = Py_BuildValue("O&",
3744 TrackObj_New, _rv);
3745 return _res;
3746 }
3747
3748 static PyObject *MovieObj_GetMoviePict(_self, _args)
3749 MovieObject *_self;
3750 PyObject *_args;
3751 {
3752 PyObject *_res = NULL;
3753 PicHandle _rv;
3754 TimeValue time;
3755 if (!PyArg_ParseTuple(_args, "l",
3756 &time))
3757 return NULL;
3758 _rv = GetMoviePict(_self->ob_itself,
3759 time);
3760 _res = Py_BuildValue("O&",
3761 ResObj_New, _rv);
3762 return _res;
3763 }
3764
3765 static PyObject *MovieObj_GetMoviePosterPict(_self, _args)
3766 MovieObject *_self;
3767 PyObject *_args;
3768 {
3769 PyObject *_res = NULL;
3770 PicHandle _rv;
3771 if (!PyArg_ParseTuple(_args, ""))
3772 return NULL;
3773 _rv = GetMoviePosterPict(_self->ob_itself);
3774 _res = Py_BuildValue("O&",
3775 ResObj_New, _rv);
3776 return _res;
3777 }
3778
3779 static PyObject *MovieObj_UpdateMovie(_self, _args)
3780 MovieObject *_self;
3781 PyObject *_args;
3782 {
3783 PyObject *_res = NULL;
3784 OSErr _err;
3785 if (!PyArg_ParseTuple(_args, ""))
3786 return NULL;
3787 _err = UpdateMovie(_self->ob_itself);
3788 if (_err != noErr) return PyMac_Error(_err);
3789 Py_INCREF(Py_None);
3790 _res = Py_None;
3791 return _res;
3792 }
3793
3794 static PyObject *MovieObj_GetMovieBox(_self, _args)
3795 MovieObject *_self;
3796 PyObject *_args;
3797 {
3798 PyObject *_res = NULL;
3799 Rect boxRect;
3800 if (!PyArg_ParseTuple(_args, ""))
3801 return NULL;
3802 GetMovieBox(_self->ob_itself,
3803 &boxRect);
3804 _res = Py_BuildValue("O&",
3805 PyMac_BuildRect, &boxRect);
3806 return _res;
3807 }
3808
3809 static PyObject *MovieObj_SetMovieBox(_self, _args)
3810 MovieObject *_self;
3811 PyObject *_args;
3812 {
3813 PyObject *_res = NULL;
3814 Rect boxRect;
3815 if (!PyArg_ParseTuple(_args, "O&",
3816 PyMac_GetRect, &boxRect))
3817 return NULL;
3818 SetMovieBox(_self->ob_itself,
3819 &boxRect);
3820 Py_INCREF(Py_None);
3821 _res = Py_None;
3822 return _res;
3823 }
3824
3825 static PyObject *MovieObj_GetMovieDisplayClipRgn(_self, _args)
3826 MovieObject *_self;
3827 PyObject *_args;
3828 {
3829 PyObject *_res = NULL;
3830 RgnHandle _rv;
3831 if (!PyArg_ParseTuple(_args, ""))
3832 return NULL;
3833 _rv = GetMovieDisplayClipRgn(_self->ob_itself);
3834 _res = Py_BuildValue("O&",
3835 ResObj_New, _rv);
3836 return _res;
3837 }
3838
3839 static PyObject *MovieObj_SetMovieDisplayClipRgn(_self, _args)
3840 MovieObject *_self;
3841 PyObject *_args;
3842 {
3843 PyObject *_res = NULL;
3844 RgnHandle theClip;
3845 if (!PyArg_ParseTuple(_args, "O&",
3846 ResObj_Convert, &theClip))
3847 return NULL;
3848 SetMovieDisplayClipRgn(_self->ob_itself,
3849 theClip);
3850 Py_INCREF(Py_None);
3851 _res = Py_None;
3852 return _res;
3853 }
3854
3855 static PyObject *MovieObj_GetMovieClipRgn(_self, _args)
3856 MovieObject *_self;
3857 PyObject *_args;
3858 {
3859 PyObject *_res = NULL;
3860 RgnHandle _rv;
3861 if (!PyArg_ParseTuple(_args, ""))
3862 return NULL;
3863 _rv = GetMovieClipRgn(_self->ob_itself);
3864 _res = Py_BuildValue("O&",
3865 ResObj_New, _rv);
3866 return _res;
3867 }
3868
3869 static PyObject *MovieObj_SetMovieClipRgn(_self, _args)
3870 MovieObject *_self;
3871 PyObject *_args;
3872 {
3873 PyObject *_res = NULL;
3874 RgnHandle theClip;
3875 if (!PyArg_ParseTuple(_args, "O&",
3876 ResObj_Convert, &theClip))
3877 return NULL;
3878 SetMovieClipRgn(_self->ob_itself,
3879 theClip);
3880 Py_INCREF(Py_None);
3881 _res = Py_None;
3882 return _res;
3883 }
3884
3885 static PyObject *MovieObj_GetMovieDisplayBoundsRgn(_self, _args)
3886 MovieObject *_self;
3887 PyObject *_args;
3888 {
3889 PyObject *_res = NULL;
3890 RgnHandle _rv;
3891 if (!PyArg_ParseTuple(_args, ""))
3892 return NULL;
3893 _rv = GetMovieDisplayBoundsRgn(_self->ob_itself);
3894 _res = Py_BuildValue("O&",
3895 ResObj_New, _rv);
3896 return _res;
3897 }
3898
3899 static PyObject *MovieObj_GetMovieBoundsRgn(_self, _args)
3900 MovieObject *_self;
3901 PyObject *_args;
3902 {
3903 PyObject *_res = NULL;
3904 RgnHandle _rv;
3905 if (!PyArg_ParseTuple(_args, ""))
3906 return NULL;
3907 _rv = GetMovieBoundsRgn(_self->ob_itself);
3908 _res = Py_BuildValue("O&",
3909 ResObj_New, _rv);
3910 return _res;
3911 }
3912
3913 static PyObject *MovieObj_PutMovieIntoHandle(_self, _args)
3914 MovieObject *_self;
3915 PyObject *_args;
3916 {
3917 PyObject *_res = NULL;
3918 OSErr _err;
3919 Handle publicMovie;
3920 if (!PyArg_ParseTuple(_args, "O&",
3921 ResObj_Convert, &publicMovie))
3922 return NULL;
3923 _err = PutMovieIntoHandle(_self->ob_itself,
3924 publicMovie);
3925 if (_err != noErr) return PyMac_Error(_err);
3926 Py_INCREF(Py_None);
3927 _res = Py_None;
3928 return _res;
3929 }
3930
3931 static PyObject *MovieObj_PutMovieIntoDataFork(_self, _args)
3932 MovieObject *_self;
3933 PyObject *_args;
3934 {
3935 PyObject *_res = NULL;
3936 OSErr _err;
3937 short fRefNum;
3938 long offset;
3939 long maxSize;
3940 if (!PyArg_ParseTuple(_args, "hll",
3941 &fRefNum,
3942 &offset,
3943 &maxSize))
3944 return NULL;
3945 _err = PutMovieIntoDataFork(_self->ob_itself,
3946 fRefNum,
3947 offset,
3948 maxSize);
3949 if (_err != noErr) return PyMac_Error(_err);
3950 Py_INCREF(Py_None);
3951 _res = Py_None;
3952 return _res;
3953 }
3954
3955 static PyObject *MovieObj_GetMovieTimeScale(_self, _args)
3956 MovieObject *_self;
3957 PyObject *_args;
3958 {
3959 PyObject *_res = NULL;
3960 TimeScale _rv;
3961 if (!PyArg_ParseTuple(_args, ""))
3962 return NULL;
3963 _rv = GetMovieTimeScale(_self->ob_itself);
3964 _res = Py_BuildValue("l",
3965 _rv);
3966 return _res;
3967 }
3968
3969 static PyObject *MovieObj_SetMovieTimeScale(_self, _args)
3970 MovieObject *_self;
3971 PyObject *_args;
3972 {
3973 PyObject *_res = NULL;
3974 TimeScale timeScale;
3975 if (!PyArg_ParseTuple(_args, "l",
3976 &timeScale))
3977 return NULL;
3978 SetMovieTimeScale(_self->ob_itself,
3979 timeScale);
3980 Py_INCREF(Py_None);
3981 _res = Py_None;
3982 return _res;
3983 }
3984
3985 static PyObject *MovieObj_GetMovieDuration(_self, _args)
3986 MovieObject *_self;
3987 PyObject *_args;
3988 {
3989 PyObject *_res = NULL;
3990 TimeValue _rv;
3991 if (!PyArg_ParseTuple(_args, ""))
3992 return NULL;
3993 _rv = GetMovieDuration(_self->ob_itself);
3994 _res = Py_BuildValue("l",
3995 _rv);
3996 return _res;
3997 }
3998
3999 static PyObject *MovieObj_GetMovieRate(_self, _args)
4000 MovieObject *_self;
4001 PyObject *_args;
4002 {
4003 PyObject *_res = NULL;
4004 Fixed _rv;
4005 if (!PyArg_ParseTuple(_args, ""))
4006 return NULL;
4007 _rv = GetMovieRate(_self->ob_itself);
4008 _res = Py_BuildValue("O&",
4009 PyMac_BuildFixed, _rv);
4010 return _res;
4011 }
4012
4013 static PyObject *MovieObj_SetMovieRate(_self, _args)
4014 MovieObject *_self;
4015 PyObject *_args;
4016 {
4017 PyObject *_res = NULL;
4018 Fixed rate;
4019 if (!PyArg_ParseTuple(_args, "O&",
4020 PyMac_GetFixed, &rate))
4021 return NULL;
4022 SetMovieRate(_self->ob_itself,
4023 rate);
4024 Py_INCREF(Py_None);
4025 _res = Py_None;
4026 return _res;
4027 }
4028
4029 static PyObject *MovieObj_GetMoviePreferredRate(_self, _args)
4030 MovieObject *_self;
4031 PyObject *_args;
4032 {
4033 PyObject *_res = NULL;
4034 Fixed _rv;
4035 if (!PyArg_ParseTuple(_args, ""))
4036 return NULL;
4037 _rv = GetMoviePreferredRate(_self->ob_itself);
4038 _res = Py_BuildValue("O&",
4039 PyMac_BuildFixed, _rv);
4040 return _res;
4041 }
4042
4043 static PyObject *MovieObj_SetMoviePreferredRate(_self, _args)
4044 MovieObject *_self;
4045 PyObject *_args;
4046 {
4047 PyObject *_res = NULL;
4048 Fixed rate;
4049 if (!PyArg_ParseTuple(_args, "O&",
4050 PyMac_GetFixed, &rate))
4051 return NULL;
4052 SetMoviePreferredRate(_self->ob_itself,
4053 rate);
4054 Py_INCREF(Py_None);
4055 _res = Py_None;
4056 return _res;
4057 }
4058
4059 static PyObject *MovieObj_GetMoviePreferredVolume(_self, _args)
4060 MovieObject *_self;
4061 PyObject *_args;
4062 {
4063 PyObject *_res = NULL;
4064 short _rv;
4065 if (!PyArg_ParseTuple(_args, ""))
4066 return NULL;
4067 _rv = GetMoviePreferredVolume(_self->ob_itself);
4068 _res = Py_BuildValue("h",
4069 _rv);
4070 return _res;
4071 }
4072
4073 static PyObject *MovieObj_SetMoviePreferredVolume(_self, _args)
4074 MovieObject *_self;
4075 PyObject *_args;
4076 {
4077 PyObject *_res = NULL;
4078 short volume;
4079 if (!PyArg_ParseTuple(_args, "h",
4080 &volume))
4081 return NULL;
4082 SetMoviePreferredVolume(_self->ob_itself,
4083 volume);
4084 Py_INCREF(Py_None);
4085 _res = Py_None;
4086 return _res;
4087 }
4088
4089 static PyObject *MovieObj_GetMovieVolume(_self, _args)
4090 MovieObject *_self;
4091 PyObject *_args;
4092 {
4093 PyObject *_res = NULL;
4094 short _rv;
4095 if (!PyArg_ParseTuple(_args, ""))
4096 return NULL;
4097 _rv = GetMovieVolume(_self->ob_itself);
4098 _res = Py_BuildValue("h",
4099 _rv);
4100 return _res;
4101 }
4102
4103 static PyObject *MovieObj_SetMovieVolume(_self, _args)
4104 MovieObject *_self;
4105 PyObject *_args;
4106 {
4107 PyObject *_res = NULL;
4108 short volume;
4109 if (!PyArg_ParseTuple(_args, "h",
4110 &volume))
4111 return NULL;
4112 SetMovieVolume(_self->ob_itself,
4113 volume);
4114 Py_INCREF(Py_None);
4115 _res = Py_None;
4116 return _res;
4117 }
4118
4119 static PyObject *MovieObj_GetMoviePreviewTime(_self, _args)
4120 MovieObject *_self;
4121 PyObject *_args;
4122 {
4123 PyObject *_res = NULL;
4124 TimeValue previewTime;
4125 TimeValue previewDuration;
4126 if (!PyArg_ParseTuple(_args, ""))
4127 return NULL;
4128 GetMoviePreviewTime(_self->ob_itself,
4129 &previewTime,
4130 &previewDuration);
4131 _res = Py_BuildValue("ll",
4132 previewTime,
4133 previewDuration);
4134 return _res;
4135 }
4136
4137 static PyObject *MovieObj_SetMoviePreviewTime(_self, _args)
4138 MovieObject *_self;
4139 PyObject *_args;
4140 {
4141 PyObject *_res = NULL;
4142 TimeValue previewTime;
4143 TimeValue previewDuration;
4144 if (!PyArg_ParseTuple(_args, "ll",
4145 &previewTime,
4146 &previewDuration))
4147 return NULL;
4148 SetMoviePreviewTime(_self->ob_itself,
4149 previewTime,
4150 previewDuration);
4151 Py_INCREF(Py_None);
4152 _res = Py_None;
4153 return _res;
4154 }
4155
4156 static PyObject *MovieObj_GetMoviePosterTime(_self, _args)
4157 MovieObject *_self;
4158 PyObject *_args;
4159 {
4160 PyObject *_res = NULL;
4161 TimeValue _rv;
4162 if (!PyArg_ParseTuple(_args, ""))
4163 return NULL;
4164 _rv = GetMoviePosterTime(_self->ob_itself);
4165 _res = Py_BuildValue("l",
4166 _rv);
4167 return _res;
4168 }
4169
4170 static PyObject *MovieObj_SetMoviePosterTime(_self, _args)
4171 MovieObject *_self;
4172 PyObject *_args;
4173 {
4174 PyObject *_res = NULL;
4175 TimeValue posterTime;
4176 if (!PyArg_ParseTuple(_args, "l",
4177 &posterTime))
4178 return NULL;
4179 SetMoviePosterTime(_self->ob_itself,
4180 posterTime);
4181 Py_INCREF(Py_None);
4182 _res = Py_None;
4183 return _res;
4184 }
4185
4186 static PyObject *MovieObj_GetMovieSelection(_self, _args)
4187 MovieObject *_self;
4188 PyObject *_args;
4189 {
4190 PyObject *_res = NULL;
4191 TimeValue selectionTime;
4192 TimeValue selectionDuration;
4193 if (!PyArg_ParseTuple(_args, ""))
4194 return NULL;
4195 GetMovieSelection(_self->ob_itself,
4196 &selectionTime,
4197 &selectionDuration);
4198 _res = Py_BuildValue("ll",
4199 selectionTime,
4200 selectionDuration);
4201 return _res;
4202 }
4203
4204 static PyObject *MovieObj_SetMovieSelection(_self, _args)
4205 MovieObject *_self;
4206 PyObject *_args;
4207 {
4208 PyObject *_res = NULL;
4209 TimeValue selectionTime;
4210 TimeValue selectionDuration;
4211 if (!PyArg_ParseTuple(_args, "ll",
4212 &selectionTime,
4213 &selectionDuration))
4214 return NULL;
4215 SetMovieSelection(_self->ob_itself,
4216 selectionTime,
4217 selectionDuration);
4218 Py_INCREF(Py_None);
4219 _res = Py_None;
4220 return _res;
4221 }
4222
4223 static PyObject *MovieObj_SetMovieActiveSegment(_self, _args)
4224 MovieObject *_self;
4225 PyObject *_args;
4226 {
4227 PyObject *_res = NULL;
4228 TimeValue startTime;
4229 TimeValue duration;
4230 if (!PyArg_ParseTuple(_args, "ll",
4231 &startTime,
4232 &duration))
4233 return NULL;
4234 SetMovieActiveSegment(_self->ob_itself,
4235 startTime,
4236 duration);
4237 Py_INCREF(Py_None);
4238 _res = Py_None;
4239 return _res;
4240 }
4241
4242 static PyObject *MovieObj_GetMovieActiveSegment(_self, _args)
4243 MovieObject *_self;
4244 PyObject *_args;
4245 {
4246 PyObject *_res = NULL;
4247 TimeValue startTime;
4248 TimeValue duration;
4249 if (!PyArg_ParseTuple(_args, ""))
4250 return NULL;
4251 GetMovieActiveSegment(_self->ob_itself,
4252 &startTime,
4253 &duration);
4254 _res = Py_BuildValue("ll",
4255 startTime,
4256 duration);
4257 return _res;
4258 }
4259
4260 static PyObject *MovieObj_SetMovieTimeValue(_self, _args)
4261 MovieObject *_self;
4262 PyObject *_args;
4263 {
4264 PyObject *_res = NULL;
4265 TimeValue newtime;
4266 if (!PyArg_ParseTuple(_args, "l",
4267 &newtime))
4268 return NULL;
4269 SetMovieTimeValue(_self->ob_itself,
4270 newtime);
4271 Py_INCREF(Py_None);
4272 _res = Py_None;
4273 return _res;
4274 }
4275
4276 static PyObject *MovieObj_GetMovieUserData(_self, _args)
4277 MovieObject *_self;
4278 PyObject *_args;
4279 {
4280 PyObject *_res = NULL;
4281 UserData _rv;
4282 if (!PyArg_ParseTuple(_args, ""))
4283 return NULL;
4284 _rv = GetMovieUserData(_self->ob_itself);
4285 _res = Py_BuildValue("O&",
4286 UserDataObj_New, _rv);
4287 return _res;
4288 }
4289
4290 static PyObject *MovieObj_GetMovieTrackCount(_self, _args)
4291 MovieObject *_self;
4292 PyObject *_args;
4293 {
4294 PyObject *_res = NULL;
4295 long _rv;
4296 if (!PyArg_ParseTuple(_args, ""))
4297 return NULL;
4298 _rv = GetMovieTrackCount(_self->ob_itself);
4299 _res = Py_BuildValue("l",
4300 _rv);
4301 return _res;
4302 }
4303
4304 static PyObject *MovieObj_GetMovieTrack(_self, _args)
4305 MovieObject *_self;
4306 PyObject *_args;
4307 {
4308 PyObject *_res = NULL;
4309 Track _rv;
4310 long trackID;
4311 if (!PyArg_ParseTuple(_args, "l",
4312 &trackID))
4313 return NULL;
4314 _rv = GetMovieTrack(_self->ob_itself,
4315 trackID);
4316 _res = Py_BuildValue("O&",
4317 TrackObj_New, _rv);
4318 return _res;
4319 }
4320
4321 static PyObject *MovieObj_GetMovieIndTrack(_self, _args)
4322 MovieObject *_self;
4323 PyObject *_args;
4324 {
4325 PyObject *_res = NULL;
4326 Track _rv;
4327 long index;
4328 if (!PyArg_ParseTuple(_args, "l",
4329 &index))
4330 return NULL;
4331 _rv = GetMovieIndTrack(_self->ob_itself,
4332 index);
4333 _res = Py_BuildValue("O&",
4334 TrackObj_New, _rv);
4335 return _res;
4336 }
4337
4338 static PyObject *MovieObj_GetMovieIndTrackType(_self, _args)
4339 MovieObject *_self;
4340 PyObject *_args;
4341 {
4342 PyObject *_res = NULL;
4343 Track _rv;
4344 long index;
4345 OSType trackType;
4346 long flags;
4347 if (!PyArg_ParseTuple(_args, "lO&l",
4348 &index,
4349 PyMac_GetOSType, &trackType,
4350 &flags))
4351 return NULL;
4352 _rv = GetMovieIndTrackType(_self->ob_itself,
4353 index,
4354 trackType,
4355 flags);
4356 _res = Py_BuildValue("O&",
4357 TrackObj_New, _rv);
4358 return _res;
4359 }
4360
4361 static PyObject *MovieObj_NewMovieTrack(_self, _args)
4362 MovieObject *_self;
4363 PyObject *_args;
4364 {
4365 PyObject *_res = NULL;
4366 Track _rv;
4367 Fixed width;
4368 Fixed height;
4369 short trackVolume;
4370 if (!PyArg_ParseTuple(_args, "O&O&h",
4371 PyMac_GetFixed, &width,
4372 PyMac_GetFixed, &height,
4373 &trackVolume))
4374 return NULL;
4375 _rv = NewMovieTrack(_self->ob_itself,
4376 width,
4377 height,
4378 trackVolume);
4379 _res = Py_BuildValue("O&",
4380 TrackObj_New, _rv);
4381 return _res;
4382 }
4383
4384 static PyObject *MovieObj_SetAutoTrackAlternatesEnabled(_self, _args)
4385 MovieObject *_self;
4386 PyObject *_args;
4387 {
4388 PyObject *_res = NULL;
4389 Boolean enable;
4390 if (!PyArg_ParseTuple(_args, "b",
4391 &enable))
4392 return NULL;
4393 SetAutoTrackAlternatesEnabled(_self->ob_itself,
4394 enable);
4395 Py_INCREF(Py_None);
4396 _res = Py_None;
4397 return _res;
4398 }
4399
4400 static PyObject *MovieObj_SelectMovieAlternates(_self, _args)
4401 MovieObject *_self;
4402 PyObject *_args;
4403 {
4404 PyObject *_res = NULL;
4405 if (!PyArg_ParseTuple(_args, ""))
4406 return NULL;
4407 SelectMovieAlternates(_self->ob_itself);
4408 Py_INCREF(Py_None);
4409 _res = Py_None;
4410 return _res;
4411 }
4412
4413 static PyObject *MovieObj_InsertMovieSegment(_self, _args)
4414 MovieObject *_self;
4415 PyObject *_args;
4416 {
4417 PyObject *_res = NULL;
4418 OSErr _err;
4419 Movie dstMovie;
4420 TimeValue srcIn;
4421 TimeValue srcDuration;
4422 TimeValue dstIn;
4423 if (!PyArg_ParseTuple(_args, "O&lll",
4424 MovieObj_Convert, &dstMovie,
4425 &srcIn,
4426 &srcDuration,
4427 &dstIn))
4428 return NULL;
4429 _err = InsertMovieSegment(_self->ob_itself,
4430 dstMovie,
4431 srcIn,
4432 srcDuration,
4433 dstIn);
4434 if (_err != noErr) return PyMac_Error(_err);
4435 Py_INCREF(Py_None);
4436 _res = Py_None;
4437 return _res;
4438 }
4439
4440 static PyObject *MovieObj_InsertEmptyMovieSegment(_self, _args)
4441 MovieObject *_self;
4442 PyObject *_args;
4443 {
4444 PyObject *_res = NULL;
4445 OSErr _err;
4446 TimeValue dstIn;
4447 TimeValue dstDuration;
4448 if (!PyArg_ParseTuple(_args, "ll",
4449 &dstIn,
4450 &dstDuration))
4451 return NULL;
4452 _err = InsertEmptyMovieSegment(_self->ob_itself,
4453 dstIn,
4454 dstDuration);
4455 if (_err != noErr) return PyMac_Error(_err);
4456 Py_INCREF(Py_None);
4457 _res = Py_None;
4458 return _res;
4459 }
4460
4461 static PyObject *MovieObj_DeleteMovieSegment(_self, _args)
4462 MovieObject *_self;
4463 PyObject *_args;
4464 {
4465 PyObject *_res = NULL;
4466 OSErr _err;
4467 TimeValue startTime;
4468 TimeValue duration;
4469 if (!PyArg_ParseTuple(_args, "ll",
4470 &startTime,
4471 &duration))
4472 return NULL;
4473 _err = DeleteMovieSegment(_self->ob_itself,
4474 startTime,
4475 duration);
4476 if (_err != noErr) return PyMac_Error(_err);
4477 Py_INCREF(Py_None);
4478 _res = Py_None;
4479 return _res;
4480 }
4481
4482 static PyObject *MovieObj_ScaleMovieSegment(_self, _args)
4483 MovieObject *_self;
4484 PyObject *_args;
4485 {
4486 PyObject *_res = NULL;
4487 OSErr _err;
4488 TimeValue startTime;
4489 TimeValue oldDuration;
4490 TimeValue newDuration;
4491 if (!PyArg_ParseTuple(_args, "lll",
4492 &startTime,
4493 &oldDuration,
4494 &newDuration))
4495 return NULL;
4496 _err = ScaleMovieSegment(_self->ob_itself,
4497 startTime,
4498 oldDuration,
4499 newDuration);
4500 if (_err != noErr) return PyMac_Error(_err);
4501 Py_INCREF(Py_None);
4502 _res = Py_None;
4503 return _res;
4504 }
4505
4506 static PyObject *MovieObj_CutMovieSelection(_self, _args)
4507 MovieObject *_self;
4508 PyObject *_args;
4509 {
4510 PyObject *_res = NULL;
4511 Movie _rv;
4512 if (!PyArg_ParseTuple(_args, ""))
4513 return NULL;
4514 _rv = CutMovieSelection(_self->ob_itself);
4515 _res = Py_BuildValue("O&",
4516 MovieObj_New, _rv);
4517 return _res;
4518 }
4519
4520 static PyObject *MovieObj_CopyMovieSelection(_self, _args)
4521 MovieObject *_self;
4522 PyObject *_args;
4523 {
4524 PyObject *_res = NULL;
4525 Movie _rv;
4526 if (!PyArg_ParseTuple(_args, ""))
4527 return NULL;
4528 _rv = CopyMovieSelection(_self->ob_itself);
4529 _res = Py_BuildValue("O&",
4530 MovieObj_New, _rv);
4531 return _res;
4532 }
4533
4534 static PyObject *MovieObj_PasteMovieSelection(_self, _args)
4535 MovieObject *_self;
4536 PyObject *_args;
4537 {
4538 PyObject *_res = NULL;
4539 Movie src;
4540 if (!PyArg_ParseTuple(_args, "O&",
4541 MovieObj_Convert, &src))
4542 return NULL;
4543 PasteMovieSelection(_self->ob_itself,
4544 src);
4545 Py_INCREF(Py_None);
4546 _res = Py_None;
4547 return _res;
4548 }
4549
4550 static PyObject *MovieObj_AddMovieSelection(_self, _args)
4551 MovieObject *_self;
4552 PyObject *_args;
4553 {
4554 PyObject *_res = NULL;
4555 Movie src;
4556 if (!PyArg_ParseTuple(_args, "O&",
4557 MovieObj_Convert, &src))
4558 return NULL;
4559 AddMovieSelection(_self->ob_itself,
4560 src);
4561 Py_INCREF(Py_None);
4562 _res = Py_None;
4563 return _res;
4564 }
4565
4566 static PyObject *MovieObj_ClearMovieSelection(_self, _args)
4567 MovieObject *_self;
4568 PyObject *_args;
4569 {
4570 PyObject *_res = NULL;
4571 if (!PyArg_ParseTuple(_args, ""))
4572 return NULL;
4573 ClearMovieSelection(_self->ob_itself);
4574 Py_INCREF(Py_None);
4575 _res = Py_None;
4576 return _res;
4577 }
4578
4579 static PyObject *MovieObj_PutMovieIntoTypedHandle(_self, _args)
4580 MovieObject *_self;
4581 PyObject *_args;
4582 {
4583 PyObject *_res = NULL;
4584 OSErr _err;
4585 Track targetTrack;
4586 OSType handleType;
4587 Handle publicMovie;
4588 TimeValue start;
4589 TimeValue dur;
4590 long flags;
4591 ComponentInstance userComp;
4592 if (!PyArg_ParseTuple(_args, "O&O&O&lllO&",
4593 TrackObj_Convert, &targetTrack,
4594 PyMac_GetOSType, &handleType,
4595 ResObj_Convert, &publicMovie,
4596 &start,
4597 &dur,
4598 &flags,
4599 CmpInstObj_Convert, &userComp))
4600 return NULL;
4601 _err = PutMovieIntoTypedHandle(_self->ob_itself,
4602 targetTrack,
4603 handleType,
4604 publicMovie,
4605 start,
4606 dur,
4607 flags,
4608 userComp);
4609 if (_err != noErr) return PyMac_Error(_err);
4610 Py_INCREF(Py_None);
4611 _res = Py_None;
4612 return _res;
4613 }
4614
4615 static PyObject *MovieObj_CopyMovieSettings(_self, _args)
4616 MovieObject *_self;
4617 PyObject *_args;
4618 {
4619 PyObject *_res = NULL;
4620 OSErr _err;
4621 Movie dstMovie;
4622 if (!PyArg_ParseTuple(_args, "O&",
4623 MovieObj_Convert, &dstMovie))
4624 return NULL;
4625 _err = CopyMovieSettings(_self->ob_itself,
4626 dstMovie);
4627 if (_err != noErr) return PyMac_Error(_err);
4628 Py_INCREF(Py_None);
4629 _res = Py_None;
4630 return _res;
4631 }
4632
4633 static PyObject *MovieObj_ConvertMovieToFile(_self, _args)
4634 MovieObject *_self;
4635 PyObject *_args;
4636 {
4637 PyObject *_res = NULL;
4638 OSErr _err;
4639 Track onlyTrack;
4640 FSSpec outputFile;
4641 OSType fileType;
4642 OSType creator;
4643 ScriptCode scriptTag;
4644 short resID;
4645 long flags;
4646 ComponentInstance userComp;
4647 if (!PyArg_ParseTuple(_args, "O&O&O&O&hlO&",
4648 TrackObj_Convert, &onlyTrack,
4649 PyMac_GetFSSpec, &outputFile,
4650 PyMac_GetOSType, &fileType,
4651 PyMac_GetOSType, &creator,
4652 &scriptTag,
4653 &flags,
4654 CmpInstObj_Convert, &userComp))
4655 return NULL;
4656 _err = ConvertMovieToFile(_self->ob_itself,
4657 onlyTrack,
4658 &outputFile,
4659 fileType,
4660 creator,
4661 scriptTag,
4662 &resID,
4663 flags,
4664 userComp);
4665 if (_err != noErr) return PyMac_Error(_err);
4666 _res = Py_BuildValue("h",
4667 resID);
4668 return _res;
4669 }
4670
4671 static PyObject *MovieObj_GetMovieDataSize(_self, _args)
4672 MovieObject *_self;
4673 PyObject *_args;
4674 {
4675 PyObject *_res = NULL;
4676 long _rv;
4677 TimeValue startTime;
4678 TimeValue duration;
4679 if (!PyArg_ParseTuple(_args, "ll",
4680 &startTime,
4681 &duration))
4682 return NULL;
4683 _rv = GetMovieDataSize(_self->ob_itself,
4684 startTime,
4685 duration);
4686 _res = Py_BuildValue("l",
4687 _rv);
4688 return _res;
4689 }
4690
4691 static PyObject *MovieObj_PtInMovie(_self, _args)
4692 MovieObject *_self;
4693 PyObject *_args;
4694 {
4695 PyObject *_res = NULL;
4696 Boolean _rv;
4697 Point pt;
4698 if (!PyArg_ParseTuple(_args, "O&",
4699 PyMac_GetPoint, &pt))
4700 return NULL;
4701 _rv = PtInMovie(_self->ob_itself,
4702 pt);
4703 _res = Py_BuildValue("b",
4704 _rv);
4705 return _res;
4706 }
4707
4708 static PyObject *MovieObj_SetMovieLanguage(_self, _args)
4709 MovieObject *_self;
4710 PyObject *_args;
4711 {
4712 PyObject *_res = NULL;
4713 long language;
4714 if (!PyArg_ParseTuple(_args, "l",
4715 &language))
4716 return NULL;
4717 SetMovieLanguage(_self->ob_itself,
4718 language);
4719 Py_INCREF(Py_None);
4720 _res = Py_None;
4721 return _res;
4722 }
4723
4724 static PyObject *MovieObj_GetMovieNextInterestingTime(_self, _args)
4725 MovieObject *_self;
4726 PyObject *_args;
4727 {
4728 PyObject *_res = NULL;
4729 short interestingTimeFlags;
4730 short numMediaTypes;
4731 OSType whichMediaTypes;
4732 TimeValue time;
4733 Fixed rate;
4734 TimeValue interestingTime;
4735 TimeValue interestingDuration;
4736 if (!PyArg_ParseTuple(_args, "hhO&lO&",
4737 &interestingTimeFlags,
4738 &numMediaTypes,
4739 PyMac_GetOSType, &whichMediaTypes,
4740 &time,
4741 PyMac_GetFixed, &rate))
4742 return NULL;
4743 GetMovieNextInterestingTime(_self->ob_itself,
4744 interestingTimeFlags,
4745 numMediaTypes,
4746 &whichMediaTypes,
4747 time,
4748 rate,
4749 &interestingTime,
4750 &interestingDuration);
4751 _res = Py_BuildValue("ll",
4752 interestingTime,
4753 interestingDuration);
4754 return _res;
4755 }
4756
4757 static PyObject *MovieObj_AddMovieResource(_self, _args)
4758 MovieObject *_self;
4759 PyObject *_args;
4760 {
4761 PyObject *_res = NULL;
4762 OSErr _err;
4763 short resRefNum;
4764 short resId;
4765 Str255 resName;
4766 if (!PyArg_ParseTuple(_args, "hO&",
4767 &resRefNum,
4768 PyMac_GetStr255, resName))
4769 return NULL;
4770 _err = AddMovieResource(_self->ob_itself,
4771 resRefNum,
4772 &resId,
4773 resName);
4774 if (_err != noErr) return PyMac_Error(_err);
4775 _res = Py_BuildValue("h",
4776 resId);
4777 return _res;
4778 }
4779
4780 static PyObject *MovieObj_UpdateMovieResource(_self, _args)
4781 MovieObject *_self;
4782 PyObject *_args;
4783 {
4784 PyObject *_res = NULL;
4785 OSErr _err;
4786 short resRefNum;
4787 short resId;
4788 Str255 resName;
4789 if (!PyArg_ParseTuple(_args, "hhO&",
4790 &resRefNum,
4791 &resId,
4792 PyMac_GetStr255, resName))
4793 return NULL;
4794 _err = UpdateMovieResource(_self->ob_itself,
4795 resRefNum,
4796 resId,
4797 resName);
4798 if (_err != noErr) return PyMac_Error(_err);
4799 Py_INCREF(Py_None);
4800 _res = Py_None;
4801 return _res;
4802 }
4803
4804 static PyObject *MovieObj_HasMovieChanged(_self, _args)
4805 MovieObject *_self;
4806 PyObject *_args;
4807 {
4808 PyObject *_res = NULL;
4809 Boolean _rv;
4810 if (!PyArg_ParseTuple(_args, ""))
4811 return NULL;
4812 _rv = HasMovieChanged(_self->ob_itself);
4813 _res = Py_BuildValue("b",
4814 _rv);
4815 return _res;
4816 }
4817
4818 static PyObject *MovieObj_ClearMovieChanged(_self, _args)
4819 MovieObject *_self;
4820 PyObject *_args;
4821 {
4822 PyObject *_res = NULL;
4823 if (!PyArg_ParseTuple(_args, ""))
4824 return NULL;
4825 ClearMovieChanged(_self->ob_itself);
4826 Py_INCREF(Py_None);
4827 _res = Py_None;
4828 return _res;
4829 }
4830
4831 static PyObject *MovieObj_SetMovieDefaultDataRef(_self, _args)
4832 MovieObject *_self;
4833 PyObject *_args;
4834 {
4835 PyObject *_res = NULL;
4836 OSErr _err;
4837 Handle dataRef;
4838 OSType dataRefType;
4839 if (!PyArg_ParseTuple(_args, "O&O&",
4840 ResObj_Convert, &dataRef,
4841 PyMac_GetOSType, &dataRefType))
4842 return NULL;
4843 _err = SetMovieDefaultDataRef(_self->ob_itself,
4844 dataRef,
4845 dataRefType);
4846 if (_err != noErr) return PyMac_Error(_err);
4847 Py_INCREF(Py_None);
4848 _res = Py_None;
4849 return _res;
4850 }
4851
4852 static PyObject *MovieObj_GetMovieDefaultDataRef(_self, _args)
4853 MovieObject *_self;
4854 PyObject *_args;
4855 {
4856 PyObject *_res = NULL;
4857 OSErr _err;
4858 Handle dataRef;
4859 OSType dataRefType;
4860 if (!PyArg_ParseTuple(_args, ""))
4861 return NULL;
4862 _err = GetMovieDefaultDataRef(_self->ob_itself,
4863 &dataRef,
4864 &dataRefType);
4865 if (_err != noErr) return PyMac_Error(_err);
4866 _res = Py_BuildValue("O&O&",
4867 ResObj_New, dataRef,
4868 PyMac_BuildOSType, dataRefType);
4869 return _res;
4870 }
4871
4872 static PyObject *MovieObj_SetMovieColorTable(_self, _args)
4873 MovieObject *_self;
4874 PyObject *_args;
4875 {
4876 PyObject *_res = NULL;
4877 OSErr _err;
4878 CTabHandle ctab;
4879 if (!PyArg_ParseTuple(_args, "O&",
4880 ResObj_Convert, &ctab))
4881 return NULL;
4882 _err = SetMovieColorTable(_self->ob_itself,
4883 ctab);
4884 if (_err != noErr) return PyMac_Error(_err);
4885 Py_INCREF(Py_None);
4886 _res = Py_None;
4887 return _res;
4888 }
4889
4890 static PyObject *MovieObj_GetMovieColorTable(_self, _args)
4891 MovieObject *_self;
4892 PyObject *_args;
4893 {
4894 PyObject *_res = NULL;
4895 OSErr _err;
4896 CTabHandle ctab;
4897 if (!PyArg_ParseTuple(_args, ""))
4898 return NULL;
4899 _err = GetMovieColorTable(_self->ob_itself,
4900 &ctab);
4901 if (_err != noErr) return PyMac_Error(_err);
4902 _res = Py_BuildValue("O&",
4903 ResObj_New, ctab);
4904 return _res;
4905 }
4906
4907 static PyObject *MovieObj_FlattenMovie(_self, _args)
4908 MovieObject *_self;
4909 PyObject *_args;
4910 {
4911 PyObject *_res = NULL;
4912 long movieFlattenFlags;
4913 FSSpec theFile;
4914 OSType creator;
4915 ScriptCode scriptTag;
4916 long createMovieFileFlags;
4917 short resId;
4918 Str255 resName;
4919 if (!PyArg_ParseTuple(_args, "lO&O&hlO&",
4920 &movieFlattenFlags,
4921 PyMac_GetFSSpec, &theFile,
4922 PyMac_GetOSType, &creator,
4923 &scriptTag,
4924 &createMovieFileFlags,
4925 PyMac_GetStr255, resName))
4926 return NULL;
4927 FlattenMovie(_self->ob_itself,
4928 movieFlattenFlags,
4929 &theFile,
4930 creator,
4931 scriptTag,
4932 createMovieFileFlags,
4933 &resId,
4934 resName);
4935 _res = Py_BuildValue("h",
4936 resId);
4937 return _res;
4938 }
4939
4940 static PyObject *MovieObj_FlattenMovieData(_self, _args)
4941 MovieObject *_self;
4942 PyObject *_args;
4943 {
4944 PyObject *_res = NULL;
4945 Movie _rv;
4946 long movieFlattenFlags;
4947 FSSpec theFile;
4948 OSType creator;
4949 ScriptCode scriptTag;
4950 long createMovieFileFlags;
4951 if (!PyArg_ParseTuple(_args, "lO&O&hl",
4952 &movieFlattenFlags,
4953 PyMac_GetFSSpec, &theFile,
4954 PyMac_GetOSType, &creator,
4955 &scriptTag,
4956 &createMovieFileFlags))
4957 return NULL;
4958 _rv = FlattenMovieData(_self->ob_itself,
4959 movieFlattenFlags,
4960 &theFile,
4961 creator,
4962 scriptTag,
4963 createMovieFileFlags);
4964 _res = Py_BuildValue("O&",
4965 MovieObj_New, _rv);
4966 return _res;
4967 }
4968
4969 static PyObject *MovieObj_MovieSearchText(_self, _args)
4970 MovieObject *_self;
4971 PyObject *_args;
4972 {
4973 PyObject *_res = NULL;
4974 OSErr _err;
4975 Ptr text;
4976 long size;
4977 long searchFlags;
4978 Track searchTrack;
4979 TimeValue searchTime;
4980 long searchOffset;
4981 if (!PyArg_ParseTuple(_args, "sll",
4982 &text,
4983 &size,
4984 &searchFlags))
4985 return NULL;
4986 _err = MovieSearchText(_self->ob_itself,
4987 text,
4988 size,
4989 searchFlags,
4990 &searchTrack,
4991 &searchTime,
4992 &searchOffset);
4993 if (_err != noErr) return PyMac_Error(_err);
4994 _res = Py_BuildValue("O&ll",
4995 TrackObj_New, searchTrack,
4996 searchTime,
4997 searchOffset);
4998 return _res;
4999 }
5000
5001 static PyObject *MovieObj_GetPosterBox(_self, _args)
5002 MovieObject *_self;
5003 PyObject *_args;
5004 {
5005 PyObject *_res = NULL;
5006 Rect boxRect;
5007 if (!PyArg_ParseTuple(_args, ""))
5008 return NULL;
5009 GetPosterBox(_self->ob_itself,
5010 &boxRect);
5011 _res = Py_BuildValue("O&",
5012 PyMac_BuildRect, &boxRect);
5013 return _res;
5014 }
5015
5016 static PyObject *MovieObj_SetPosterBox(_self, _args)
5017 MovieObject *_self;
5018 PyObject *_args;
5019 {
5020 PyObject *_res = NULL;
5021 Rect boxRect;
5022 if (!PyArg_ParseTuple(_args, "O&",
5023 PyMac_GetRect, &boxRect))
5024 return NULL;
5025 SetPosterBox(_self->ob_itself,
5026 &boxRect);
5027 Py_INCREF(Py_None);
5028 _res = Py_None;
5029 return _res;
5030 }
5031
5032 static PyObject *MovieObj_GetMovieSegmentDisplayBoundsRgn(_self, _args)
5033 MovieObject *_self;
5034 PyObject *_args;
5035 {
5036 PyObject *_res = NULL;
5037 RgnHandle _rv;
5038 TimeValue time;
5039 TimeValue duration;
5040 if (!PyArg_ParseTuple(_args, "ll",
5041 &time,
5042 &duration))
5043 return NULL;
5044 _rv = GetMovieSegmentDisplayBoundsRgn(_self->ob_itself,
5045 time,
5046 duration);
5047 _res = Py_BuildValue("O&",
5048 ResObj_New, _rv);
5049 return _res;
5050 }
5051
5052 static PyObject *MovieObj_GetMovieStatus(_self, _args)
5053 MovieObject *_self;
5054 PyObject *_args;
5055 {
5056 PyObject *_res = NULL;
5057 ComponentResult _rv;
5058 Track firstProblemTrack;
5059 if (!PyArg_ParseTuple(_args, ""))
5060 return NULL;
5061 _rv = GetMovieStatus(_self->ob_itself,
5062 &firstProblemTrack);
5063 _res = Py_BuildValue("lO&",
5064 _rv,
5065 TrackObj_New, firstProblemTrack);
5066 return _res;
5067 }
5068
5069 static PyObject *MovieObj_NewMovieController(_self, _args)
5070 MovieObject *_self;
5071 PyObject *_args;
5072 {
5073 PyObject *_res = NULL;
5074 MovieController _rv;
5075 Rect movieRect;
5076 long someFlags;
5077 if (!PyArg_ParseTuple(_args, "O&l",
5078 PyMac_GetRect, &movieRect,
5079 &someFlags))
5080 return NULL;
5081 _rv = NewMovieController(_self->ob_itself,
5082 &movieRect,
5083 someFlags);
5084 _res = Py_BuildValue("O&",
5085 MovieCtlObj_New, _rv);
5086 return _res;
5087 }
5088
5089 static PyObject *MovieObj_PutMovieOnScrap(_self, _args)
5090 MovieObject *_self;
5091 PyObject *_args;
5092 {
5093 PyObject *_res = NULL;
5094 OSErr _err;
5095 long movieScrapFlags;
5096 if (!PyArg_ParseTuple(_args, "l",
5097 &movieScrapFlags))
5098 return NULL;
5099 _err = PutMovieOnScrap(_self->ob_itself,
5100 movieScrapFlags);
5101 if (_err != noErr) return PyMac_Error(_err);
5102 Py_INCREF(Py_None);
5103 _res = Py_None;
5104 return _res;
5105 }
5106
5107 static PyObject *MovieObj_SetMoviePlayHints(_self, _args)
5108 MovieObject *_self;
5109 PyObject *_args;
5110 {
5111 PyObject *_res = NULL;
5112 long flags;
5113 long flagsMask;
5114 if (!PyArg_ParseTuple(_args, "ll",
5115 &flags,
5116 &flagsMask))
5117 return NULL;
5118 SetMoviePlayHints(_self->ob_itself,
5119 flags,
5120 flagsMask);
5121 Py_INCREF(Py_None);
5122 _res = Py_None;
5123 return _res;
5124 }
5125
5126 static PyMethodDef MovieObj_methods[] = {
5127 {"MoviesTask", (PyCFunction)MovieObj_MoviesTask, 1,
5128 "(long maxMilliSecToUse) -> None"},
5129 {"PrerollMovie", (PyCFunction)MovieObj_PrerollMovie, 1,
5130 "(TimeValue time, Fixed Rate) -> None"},
5131 {"LoadMovieIntoRam", (PyCFunction)MovieObj_LoadMovieIntoRam, 1,
5132 "(TimeValue time, TimeValue duration, long flags) -> None"},
5133 {"SetMovieActive", (PyCFunction)MovieObj_SetMovieActive, 1,
5134 "(Boolean active) -> None"},
5135 {"GetMovieActive", (PyCFunction)MovieObj_GetMovieActive, 1,
5136 "() -> (Boolean _rv)"},
5137 {"StartMovie", (PyCFunction)MovieObj_StartMovie, 1,
5138 "() -> None"},
5139 {"StopMovie", (PyCFunction)MovieObj_StopMovie, 1,
5140 "() -> None"},
5141 {"GoToBeginningOfMovie", (PyCFunction)MovieObj_GoToBeginningOfMovie, 1,
5142 "() -> None"},
5143 {"GoToEndOfMovie", (PyCFunction)MovieObj_GoToEndOfMovie, 1,
5144 "() -> None"},
5145 {"IsMovieDone", (PyCFunction)MovieObj_IsMovieDone, 1,
5146 "() -> (Boolean _rv)"},
5147 {"GetMoviePreviewMode", (PyCFunction)MovieObj_GetMoviePreviewMode, 1,
5148 "() -> (Boolean _rv)"},
5149 {"SetMoviePreviewMode", (PyCFunction)MovieObj_SetMoviePreviewMode, 1,
5150 "(Boolean usePreview) -> None"},
5151 {"ShowMoviePoster", (PyCFunction)MovieObj_ShowMoviePoster, 1,
5152 "() -> None"},
5153 {"GetMovieTimeBase", (PyCFunction)MovieObj_GetMovieTimeBase, 1,
5154 "() -> (TimeBase _rv)"},
5155 {"GetNextTrackForCompositing", (PyCFunction)MovieObj_GetNextTrackForCompositing, 1,
5156 "(Track theTrack) -> (Track _rv)"},
5157 {"GetPrevTrackForCompositing", (PyCFunction)MovieObj_GetPrevTrackForCompositing, 1,
5158 "(Track theTrack) -> (Track _rv)"},
5159 {"GetMoviePict", (PyCFunction)MovieObj_GetMoviePict, 1,
5160 "(TimeValue time) -> (PicHandle _rv)"},
5161 {"GetMoviePosterPict", (PyCFunction)MovieObj_GetMoviePosterPict, 1,
5162 "() -> (PicHandle _rv)"},
5163 {"UpdateMovie", (PyCFunction)MovieObj_UpdateMovie, 1,
5164 "() -> None"},
5165 {"GetMovieBox", (PyCFunction)MovieObj_GetMovieBox, 1,
5166 "() -> (Rect boxRect)"},
5167 {"SetMovieBox", (PyCFunction)MovieObj_SetMovieBox, 1,
5168 "(Rect boxRect) -> None"},
5169 {"GetMovieDisplayClipRgn", (PyCFunction)MovieObj_GetMovieDisplayClipRgn, 1,
5170 "() -> (RgnHandle _rv)"},
5171 {"SetMovieDisplayClipRgn", (PyCFunction)MovieObj_SetMovieDisplayClipRgn, 1,
5172 "(RgnHandle theClip) -> None"},
5173 {"GetMovieClipRgn", (PyCFunction)MovieObj_GetMovieClipRgn, 1,
5174 "() -> (RgnHandle _rv)"},
5175 {"SetMovieClipRgn", (PyCFunction)MovieObj_SetMovieClipRgn, 1,
5176 "(RgnHandle theClip) -> None"},
5177 {"GetMovieDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieDisplayBoundsRgn, 1,
5178 "() -> (RgnHandle _rv)"},
5179 {"GetMovieBoundsRgn", (PyCFunction)MovieObj_GetMovieBoundsRgn, 1,
5180 "() -> (RgnHandle _rv)"},
5181 {"PutMovieIntoHandle", (PyCFunction)MovieObj_PutMovieIntoHandle, 1,
5182 "(Handle publicMovie) -> None"},
5183 {"PutMovieIntoDataFork", (PyCFunction)MovieObj_PutMovieIntoDataFork, 1,
5184 "(short fRefNum, long offset, long maxSize) -> None"},
5185 {"GetMovieTimeScale", (PyCFunction)MovieObj_GetMovieTimeScale, 1,
5186 "() -> (TimeScale _rv)"},
5187 {"SetMovieTimeScale", (PyCFunction)MovieObj_SetMovieTimeScale, 1,
5188 "(TimeScale timeScale) -> None"},
5189 {"GetMovieDuration", (PyCFunction)MovieObj_GetMovieDuration, 1,
5190 "() -> (TimeValue _rv)"},
5191 {"GetMovieRate", (PyCFunction)MovieObj_GetMovieRate, 1,
5192 "() -> (Fixed _rv)"},
5193 {"SetMovieRate", (PyCFunction)MovieObj_SetMovieRate, 1,
5194 "(Fixed rate) -> None"},
5195 {"GetMoviePreferredRate", (PyCFunction)MovieObj_GetMoviePreferredRate, 1,
5196 "() -> (Fixed _rv)"},
5197 {"SetMoviePreferredRate", (PyCFunction)MovieObj_SetMoviePreferredRate, 1,
5198 "(Fixed rate) -> None"},
5199 {"GetMoviePreferredVolume", (PyCFunction)MovieObj_GetMoviePreferredVolume, 1,
5200 "() -> (short _rv)"},
5201 {"SetMoviePreferredVolume", (PyCFunction)MovieObj_SetMoviePreferredVolume, 1,
5202 "(short volume) -> None"},
5203 {"GetMovieVolume", (PyCFunction)MovieObj_GetMovieVolume, 1,
5204 "() -> (short _rv)"},
5205 {"SetMovieVolume", (PyCFunction)MovieObj_SetMovieVolume, 1,
5206 "(short volume) -> None"},
5207 {"GetMoviePreviewTime", (PyCFunction)MovieObj_GetMoviePreviewTime, 1,
5208 "() -> (TimeValue previewTime, TimeValue previewDuration)"},
5209 {"SetMoviePreviewTime", (PyCFunction)MovieObj_SetMoviePreviewTime, 1,
5210 "(TimeValue previewTime, TimeValue previewDuration) -> None"},
5211 {"GetMoviePosterTime", (PyCFunction)MovieObj_GetMoviePosterTime, 1,
5212 "() -> (TimeValue _rv)"},
5213 {"SetMoviePosterTime", (PyCFunction)MovieObj_SetMoviePosterTime, 1,
5214 "(TimeValue posterTime) -> None"},
5215 {"GetMovieSelection", (PyCFunction)MovieObj_GetMovieSelection, 1,
5216 "() -> (TimeValue selectionTime, TimeValue selectionDuration)"},
5217 {"SetMovieSelection", (PyCFunction)MovieObj_SetMovieSelection, 1,
5218 "(TimeValue selectionTime, TimeValue selectionDuration) -> None"},
5219 {"SetMovieActiveSegment", (PyCFunction)MovieObj_SetMovieActiveSegment, 1,
5220 "(TimeValue startTime, TimeValue duration) -> None"},
5221 {"GetMovieActiveSegment", (PyCFunction)MovieObj_GetMovieActiveSegment, 1,
5222 "() -> (TimeValue startTime, TimeValue duration)"},
5223 {"SetMovieTimeValue", (PyCFunction)MovieObj_SetMovieTimeValue, 1,
5224 "(TimeValue newtime) -> None"},
5225 {"GetMovieUserData", (PyCFunction)MovieObj_GetMovieUserData, 1,
5226 "() -> (UserData _rv)"},
5227 {"GetMovieTrackCount", (PyCFunction)MovieObj_GetMovieTrackCount, 1,
5228 "() -> (long _rv)"},
5229 {"GetMovieTrack", (PyCFunction)MovieObj_GetMovieTrack, 1,
5230 "(long trackID) -> (Track _rv)"},
5231 {"GetMovieIndTrack", (PyCFunction)MovieObj_GetMovieIndTrack, 1,
5232 "(long index) -> (Track _rv)"},
5233 {"GetMovieIndTrackType", (PyCFunction)MovieObj_GetMovieIndTrackType, 1,
5234 "(long index, OSType trackType, long flags) -> (Track _rv)"},
5235 {"NewMovieTrack", (PyCFunction)MovieObj_NewMovieTrack, 1,
5236 "(Fixed width, Fixed height, short trackVolume) -> (Track _rv)"},
5237 {"SetAutoTrackAlternatesEnabled", (PyCFunction)MovieObj_SetAutoTrackAlternatesEnabled, 1,
5238 "(Boolean enable) -> None"},
5239 {"SelectMovieAlternates", (PyCFunction)MovieObj_SelectMovieAlternates, 1,
5240 "() -> None"},
5241 {"InsertMovieSegment", (PyCFunction)MovieObj_InsertMovieSegment, 1,
5242 "(Movie dstMovie, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None"},
5243 {"InsertEmptyMovieSegment", (PyCFunction)MovieObj_InsertEmptyMovieSegment, 1,
5244 "(TimeValue dstIn, TimeValue dstDuration) -> None"},
5245 {"DeleteMovieSegment", (PyCFunction)MovieObj_DeleteMovieSegment, 1,
5246 "(TimeValue startTime, TimeValue duration) -> None"},
5247 {"ScaleMovieSegment", (PyCFunction)MovieObj_ScaleMovieSegment, 1,
5248 "(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None"},
5249 {"CutMovieSelection", (PyCFunction)MovieObj_CutMovieSelection, 1,
5250 "() -> (Movie _rv)"},
5251 {"CopyMovieSelection", (PyCFunction)MovieObj_CopyMovieSelection, 1,
5252 "() -> (Movie _rv)"},
5253 {"PasteMovieSelection", (PyCFunction)MovieObj_PasteMovieSelection, 1,
5254 "(Movie src) -> None"},
5255 {"AddMovieSelection", (PyCFunction)MovieObj_AddMovieSelection, 1,
5256 "(Movie src) -> None"},
5257 {"ClearMovieSelection", (PyCFunction)MovieObj_ClearMovieSelection, 1,
5258 "() -> None"},
5259 {"PutMovieIntoTypedHandle", (PyCFunction)MovieObj_PutMovieIntoTypedHandle, 1,
5260 "(Track targetTrack, OSType handleType, Handle publicMovie, TimeValue start, TimeValue dur, long flags, ComponentInstance userComp) -> None"},
5261 {"CopyMovieSettings", (PyCFunction)MovieObj_CopyMovieSettings, 1,
5262 "(Movie dstMovie) -> None"},
5263 {"ConvertMovieToFile", (PyCFunction)MovieObj_ConvertMovieToFile, 1,
5264 "(Track onlyTrack, FSSpec outputFile, OSType fileType, OSType creator, ScriptCode scriptTag, long flags, ComponentInstance userComp) -> (short resID)"},
5265 {"GetMovieDataSize", (PyCFunction)MovieObj_GetMovieDataSize, 1,
5266 "(TimeValue startTime, TimeValue duration) -> (long _rv)"},
5267 {"PtInMovie", (PyCFunction)MovieObj_PtInMovie, 1,
5268 "(Point pt) -> (Boolean _rv)"},
5269 {"SetMovieLanguage", (PyCFunction)MovieObj_SetMovieLanguage, 1,
5270 "(long language) -> None"},
5271 {"GetMovieNextInterestingTime", (PyCFunction)MovieObj_GetMovieNextInterestingTime, 1,
5272 "(short interestingTimeFlags, short numMediaTypes, OSType whichMediaTypes, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
5273 {"AddMovieResource", (PyCFunction)MovieObj_AddMovieResource, 1,
5274 "(short resRefNum, Str255 resName) -> (short resId)"},
5275 {"UpdateMovieResource", (PyCFunction)MovieObj_UpdateMovieResource, 1,
5276 "(short resRefNum, short resId, Str255 resName) -> None"},
5277 {"HasMovieChanged", (PyCFunction)MovieObj_HasMovieChanged, 1,
5278 "() -> (Boolean _rv)"},
5279 {"ClearMovieChanged", (PyCFunction)MovieObj_ClearMovieChanged, 1,
5280 "() -> None"},
5281 {"SetMovieDefaultDataRef", (PyCFunction)MovieObj_SetMovieDefaultDataRef, 1,
5282 "(Handle dataRef, OSType dataRefType) -> None"},
5283 {"GetMovieDefaultDataRef", (PyCFunction)MovieObj_GetMovieDefaultDataRef, 1,
5284 "() -> (Handle dataRef, OSType dataRefType)"},
5285 {"SetMovieColorTable", (PyCFunction)MovieObj_SetMovieColorTable, 1,
5286 "(CTabHandle ctab) -> None"},
5287 {"GetMovieColorTable", (PyCFunction)MovieObj_GetMovieColorTable, 1,
5288 "() -> (CTabHandle ctab)"},
5289 {"FlattenMovie", (PyCFunction)MovieObj_FlattenMovie, 1,
5290 "(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Str255 resName) -> (short resId)"},
5291 {"FlattenMovieData", (PyCFunction)MovieObj_FlattenMovieData, 1,
5292 "(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (Movie _rv)"},
5293 {"MovieSearchText", (PyCFunction)MovieObj_MovieSearchText, 1,
5294 "(Ptr text, long size, long searchFlags) -> (Track searchTrack, TimeValue searchTime, long searchOffset)"},
5295 {"GetPosterBox", (PyCFunction)MovieObj_GetPosterBox, 1,
5296 "() -> (Rect boxRect)"},
5297 {"SetPosterBox", (PyCFunction)MovieObj_SetPosterBox, 1,
5298 "(Rect boxRect) -> None"},
5299 {"GetMovieSegmentDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieSegmentDisplayBoundsRgn, 1,
5300 "(TimeValue time, TimeValue duration) -> (RgnHandle _rv)"},
5301 {"GetMovieStatus", (PyCFunction)MovieObj_GetMovieStatus, 1,
5302 "() -> (ComponentResult _rv, Track firstProblemTrack)"},
5303 {"NewMovieController", (PyCFunction)MovieObj_NewMovieController, 1,
5304 "(Rect movieRect, long someFlags) -> (MovieController _rv)"},
5305 {"PutMovieOnScrap", (PyCFunction)MovieObj_PutMovieOnScrap, 1,
5306 "(long movieScrapFlags) -> None"},
5307 {"SetMoviePlayHints", (PyCFunction)MovieObj_SetMoviePlayHints, 1,
5308 "(long flags, long flagsMask) -> None"},
5309 {NULL, NULL, 0}
5310 };
5311
5312 PyMethodChain MovieObj_chain = { MovieObj_methods, NULL };
5313
5314 static PyObject *MovieObj_getattr(self, name)
5315 MovieObject *self;
5316 char *name;
5317 {
5318 return Py_FindMethodInChain(&MovieObj_chain, (PyObject *)self, name);
5319 }
5320
5321 #define MovieObj_setattr NULL
5322
5323 PyTypeObject Movie_Type = {
5324 PyObject_HEAD_INIT(&PyType_Type)
5325 0, /*ob_size*/
5326 "Movie", /*tp_name*/
5327 sizeof(MovieObject), /*tp_basicsize*/
5328 0, /*tp_itemsize*/
5329 /* methods */
5330 (destructor) MovieObj_dealloc, /*tp_dealloc*/
5331 0, /*tp_print*/
5332 (getattrfunc) MovieObj_getattr, /*tp_getattr*/
5333 (setattrfunc) MovieObj_setattr, /*tp_setattr*/
5334 };
5335
5336 /* --------------------- End object type Movie ---------------------- */
5337
5338
5339 static PyObject *Qt_EnterMovies(_self, _args)
5340 PyObject *_self;
5341 PyObject *_args;
5342 {
5343 PyObject *_res = NULL;
5344 OSErr _err;
5345 if (!PyArg_ParseTuple(_args, ""))
5346 return NULL;
5347 _err = EnterMovies();
5348 if (_err != noErr) return PyMac_Error(_err);
5349 Py_INCREF(Py_None);
5350 _res = Py_None;
5351 return _res;
5352 }
5353
5354 static PyObject *Qt_ExitMovies(_self, _args)
5355 PyObject *_self;
5356 PyObject *_args;
5357 {
5358 PyObject *_res = NULL;
5359 if (!PyArg_ParseTuple(_args, ""))
5360 return NULL;
5361 ExitMovies();
5362 Py_INCREF(Py_None);
5363 _res = Py_None;
5364 return _res;
5365 }
5366
5367 static PyObject *Qt_GetMoviesError(_self, _args)
5368 PyObject *_self;
5369 PyObject *_args;
5370 {
5371 PyObject *_res = NULL;
5372 OSErr _err;
5373 if (!PyArg_ParseTuple(_args, ""))
5374 return NULL;
5375 _err = GetMoviesError();
5376 if (_err != noErr) return PyMac_Error(_err);
5377 Py_INCREF(Py_None);
5378 _res = Py_None;
5379 return _res;
5380 }
5381
5382 static PyObject *Qt_ClearMoviesStickyError(_self, _args)
5383 PyObject *_self;
5384 PyObject *_args;
5385 {
5386 PyObject *_res = NULL;
5387 if (!PyArg_ParseTuple(_args, ""))
5388 return NULL;
5389 ClearMoviesStickyError();
5390 Py_INCREF(Py_None);
5391 _res = Py_None;
5392 return _res;
5393 }
5394
5395 static PyObject *Qt_GetMoviesStickyError(_self, _args)
5396 PyObject *_self;
5397 PyObject *_args;
5398 {
5399 PyObject *_res = NULL;
5400 OSErr _err;
5401 if (!PyArg_ParseTuple(_args, ""))
5402 return NULL;
5403 _err = GetMoviesStickyError();
5404 if (_err != noErr) return PyMac_Error(_err);
5405 Py_INCREF(Py_None);
5406 _res = Py_None;
5407 return _res;
5408 }
5409
5410 static PyObject *Qt_DisposeMatte(_self, _args)
5411 PyObject *_self;
5412 PyObject *_args;
5413 {
5414 PyObject *_res = NULL;
5415 PixMapHandle theMatte;
5416 if (!PyArg_ParseTuple(_args, "O&",
5417 ResObj_Convert, &theMatte))
5418 return NULL;
5419 DisposeMatte(theMatte);
5420 Py_INCREF(Py_None);
5421 _res = Py_None;
5422 return _res;
5423 }
5424
5425 static PyObject *Qt_NewMovie(_self, _args)
5426 PyObject *_self;
5427 PyObject *_args;
5428 {
5429 PyObject *_res = NULL;
5430 Movie _rv;
5431 long flags;
5432 if (!PyArg_ParseTuple(_args, "l",
5433 &flags))
5434 return NULL;
5435 _rv = NewMovie(flags);
5436 _res = Py_BuildValue("O&",
5437 MovieObj_New, _rv);
5438 return _res;
5439 }
5440
5441 static PyObject *Qt_GetDataHandler(_self, _args)
5442 PyObject *_self;
5443 PyObject *_args;
5444 {
5445 PyObject *_res = NULL;
5446 Component _rv;
5447 Handle dataRef;
5448 OSType dataHandlerSubType;
5449 long flags;
5450 if (!PyArg_ParseTuple(_args, "O&O&l",
5451 ResObj_Convert, &dataRef,
5452 PyMac_GetOSType, &dataHandlerSubType,
5453 &flags))
5454 return NULL;
5455 _rv = GetDataHandler(dataRef,
5456 dataHandlerSubType,
5457 flags);
5458 _res = Py_BuildValue("O&",
5459 CmpObj_New, _rv);
5460 return _res;
5461 }
5462
5463 static PyObject *Qt_PasteHandleIntoMovie(_self, _args)
5464 PyObject *_self;
5465 PyObject *_args;
5466 {
5467 PyObject *_res = NULL;
5468 OSErr _err;
5469 Handle h;
5470 OSType handleType;
5471 Movie theMovie;
5472 long flags;
5473 ComponentInstance userComp;
5474 if (!PyArg_ParseTuple(_args, "O&O&O&lO&",
5475 ResObj_Convert, &h,
5476 PyMac_GetOSType, &handleType,
5477 MovieObj_Convert, &theMovie,
5478 &flags,
5479 CmpInstObj_Convert, &userComp))
5480 return NULL;
5481 _err = PasteHandleIntoMovie(h,
5482 handleType,
5483 theMovie,
5484 flags,
5485 userComp);
5486 if (_err != noErr) return PyMac_Error(_err);
5487 Py_INCREF(Py_None);
5488 _res = Py_None;
5489 return _res;
5490 }
5491
5492 static PyObject *Qt_TrackTimeToMediaTime(_self, _args)
5493 PyObject *_self;
5494 PyObject *_args;
5495 {
5496 PyObject *_res = NULL;
5497 TimeValue _rv;
5498 TimeValue value;
5499 Track theTrack;
5500 if (!PyArg_ParseTuple(_args, "lO&",
5501 &value,
5502 TrackObj_Convert, &theTrack))
5503 return NULL;
5504 _rv = TrackTimeToMediaTime(value,
5505 theTrack);
5506 _res = Py_BuildValue("l",
5507 _rv);
5508 return _res;
5509 }
5510
5511 static PyObject *Qt_NewUserData(_self, _args)
5512 PyObject *_self;
5513 PyObject *_args;
5514 {
5515 PyObject *_res = NULL;
5516 OSErr _err;
5517 UserData theUserData;
5518 if (!PyArg_ParseTuple(_args, ""))
5519 return NULL;
5520 _err = NewUserData(&theUserData);
5521 if (_err != noErr) return PyMac_Error(_err);
5522 _res = Py_BuildValue("O&",
5523 UserDataObj_New, theUserData);
5524 return _res;
5525 }
5526
5527 static PyObject *Qt_NewUserDataFromHandle(_self, _args)
5528 PyObject *_self;
5529 PyObject *_args;
5530 {
5531 PyObject *_res = NULL;
5532 OSErr _err;
5533 Handle h;
5534 UserData theUserData;
5535 if (!PyArg_ParseTuple(_args, "O&",
5536 ResObj_Convert, &h))
5537 return NULL;
5538 _err = NewUserDataFromHandle(h,
5539 &theUserData);
5540 if (_err != noErr) return PyMac_Error(_err);
5541 _res = Py_BuildValue("O&",
5542 UserDataObj_New, theUserData);
5543 return _res;
5544 }
5545
5546 static PyObject *Qt_CreateMovieFile(_self, _args)
5547 PyObject *_self;
5548 PyObject *_args;
5549 {
5550 PyObject *_res = NULL;
5551 OSErr _err;
5552 FSSpec fileSpec;
5553 OSType creator;
5554 ScriptCode scriptTag;
5555 long createMovieFileFlags;
5556 short resRefNum;
5557 Movie newmovie;
5558 if (!PyArg_ParseTuple(_args, "O&O&hl",
5559 PyMac_GetFSSpec, &fileSpec,
5560 PyMac_GetOSType, &creator,
5561 &scriptTag,
5562 &createMovieFileFlags))
5563 return NULL;
5564 _err = CreateMovieFile(&fileSpec,
5565 creator,
5566 scriptTag,
5567 createMovieFileFlags,
5568 &resRefNum,
5569 &newmovie);
5570 if (_err != noErr) return PyMac_Error(_err);
5571 _res = Py_BuildValue("hO&",
5572 resRefNum,
5573 MovieObj_New, newmovie);
5574 return _res;
5575 }
5576
5577 static PyObject *Qt_OpenMovieFile(_self, _args)
5578 PyObject *_self;
5579 PyObject *_args;
5580 {
5581 PyObject *_res = NULL;
5582 OSErr _err;
5583 FSSpec fileSpec;
5584 short resRefNum;
5585 SInt8 permission;
5586 if (!PyArg_ParseTuple(_args, "O&b",
5587 PyMac_GetFSSpec, &fileSpec,
5588 &permission))
5589 return NULL;
5590 _err = OpenMovieFile(&fileSpec,
5591 &resRefNum,
5592 permission);
5593 if (_err != noErr) return PyMac_Error(_err);
5594 _res = Py_BuildValue("h",
5595 resRefNum);
5596 return _res;
5597 }
5598
5599 static PyObject *Qt_CloseMovieFile(_self, _args)
5600 PyObject *_self;
5601 PyObject *_args;
5602 {
5603 PyObject *_res = NULL;
5604 OSErr _err;
5605 short resRefNum;
5606 if (!PyArg_ParseTuple(_args, "h",
5607 &resRefNum))
5608 return NULL;
5609 _err = CloseMovieFile(resRefNum);
5610 if (_err != noErr) return PyMac_Error(_err);
5611 Py_INCREF(Py_None);
5612 _res = Py_None;
5613 return _res;
5614 }
5615
5616 static PyObject *Qt_DeleteMovieFile(_self, _args)
5617 PyObject *_self;
5618 PyObject *_args;
5619 {
5620 PyObject *_res = NULL;
5621 OSErr _err;
5622 FSSpec fileSpec;
5623 if (!PyArg_ParseTuple(_args, "O&",
5624 PyMac_GetFSSpec, &fileSpec))
5625 return NULL;
5626 _err = DeleteMovieFile(&fileSpec);
5627 if (_err != noErr) return PyMac_Error(_err);
5628 Py_INCREF(Py_None);
5629 _res = Py_None;
5630 return _res;
5631 }
5632
5633 static PyObject *Qt_NewMovieFromFile(_self, _args)
5634 PyObject *_self;
5635 PyObject *_args;
5636 {
5637 PyObject *_res = NULL;
5638 OSErr _err;
5639 Movie theMovie;
5640 short resRefNum;
5641 short newMovieFlags;
5642 Boolean dataRefWasChanged;
5643 if (!PyArg_ParseTuple(_args, "hh",
5644 &resRefNum,
5645 &newMovieFlags))
5646 return NULL;
5647 _err = NewMovieFromFile(&theMovie,
5648 resRefNum,
5649 (short *)0,
5650 (StringPtr)0,
5651 newMovieFlags,
5652 &dataRefWasChanged);
5653 if (_err != noErr) return PyMac_Error(_err);
5654 _res = Py_BuildValue("O&b",
5655 MovieObj_New, theMovie,
5656 dataRefWasChanged);
5657 return _res;
5658 }
5659
5660 static PyObject *Qt_NewMovieFromHandle(_self, _args)
5661 PyObject *_self;
5662 PyObject *_args;
5663 {
5664 PyObject *_res = NULL;
5665 OSErr _err;
5666 Movie theMovie;
5667 Handle h;
5668 short newMovieFlags;
5669 Boolean dataRefWasChanged;
5670 if (!PyArg_ParseTuple(_args, "O&h",
5671 ResObj_Convert, &h,
5672 &newMovieFlags))
5673 return NULL;
5674 _err = NewMovieFromHandle(&theMovie,
5675 h,
5676 newMovieFlags,
5677 &dataRefWasChanged);
5678 if (_err != noErr) return PyMac_Error(_err);
5679 _res = Py_BuildValue("O&b",
5680 MovieObj_New, theMovie,
5681 dataRefWasChanged);
5682 return _res;
5683 }
5684
5685 static PyObject *Qt_NewMovieFromDataFork(_self, _args)
5686 PyObject *_self;
5687 PyObject *_args;
5688 {
5689 PyObject *_res = NULL;
5690 OSErr _err;
5691 Movie theMovie;
5692 short fRefNum;
5693 long fileOffset;
5694 short newMovieFlags;
5695 Boolean dataRefWasChanged;
5696 if (!PyArg_ParseTuple(_args, "hlh",
5697 &fRefNum,
5698 &fileOffset,
5699 &newMovieFlags))
5700 return NULL;
5701 _err = NewMovieFromDataFork(&theMovie,
5702 fRefNum,
5703 fileOffset,
5704 newMovieFlags,
5705 &dataRefWasChanged);
5706 if (_err != noErr) return PyMac_Error(_err);
5707 _res = Py_BuildValue("O&b",
5708 MovieObj_New, theMovie,
5709 dataRefWasChanged);
5710 return _res;
5711 }
5712
5713 static PyObject *Qt_RemoveMovieResource(_self, _args)
5714 PyObject *_self;
5715 PyObject *_args;
5716 {
5717 PyObject *_res = NULL;
5718 OSErr _err;
5719 short resRefNum;
5720 short resId;
5721 if (!PyArg_ParseTuple(_args, "hh",
5722 &resRefNum,
5723 &resId))
5724 return NULL;
5725 _err = RemoveMovieResource(resRefNum,
5726 resId);
5727 if (_err != noErr) return PyMac_Error(_err);
5728 Py_INCREF(Py_None);
5729 _res = Py_None;
5730 return _res;
5731 }
5732
5733 static PyObject *Qt_GetVideoMediaGraphicsMode(_self, _args)
5734 PyObject *_self;
5735 PyObject *_args;
5736 {
5737 PyObject *_res = NULL;
5738 HandlerError _rv;
5739 MediaHandler mh;
5740 long graphicsMode;
5741 RGBColor opColor;
5742 if (!PyArg_ParseTuple(_args, "O&",
5743 CmpInstObj_Convert, &mh))
5744 return NULL;
5745 _rv = GetVideoMediaGraphicsMode(mh,
5746 &graphicsMode,
5747 &opColor);
5748 _res = Py_BuildValue("llO&",
5749 _rv,
5750 graphicsMode,
5751 QdRGB_New, &opColor);
5752 return _res;
5753 }
5754
5755 static PyObject *Qt_SetVideoMediaGraphicsMode(_self, _args)
5756 PyObject *_self;
5757 PyObject *_args;
5758 {
5759 PyObject *_res = NULL;
5760 HandlerError _rv;
5761 MediaHandler mh;
5762 long graphicsMode;
5763 RGBColor opColor;
5764 if (!PyArg_ParseTuple(_args, "O&lO&",
5765 CmpInstObj_Convert, &mh,
5766 &graphicsMode,
5767 QdRGB_Convert, &opColor))
5768 return NULL;
5769 _rv = SetVideoMediaGraphicsMode(mh,
5770 graphicsMode,
5771 &opColor);
5772 _res = Py_BuildValue("l",
5773 _rv);
5774 return _res;
5775 }
5776
5777 static PyObject *Qt_GetSoundMediaBalance(_self, _args)
5778 PyObject *_self;
5779 PyObject *_args;
5780 {
5781 PyObject *_res = NULL;
5782 HandlerError _rv;
5783 MediaHandler mh;
5784 short balance;
5785 if (!PyArg_ParseTuple(_args, "O&",
5786 CmpInstObj_Convert, &mh))
5787 return NULL;
5788 _rv = GetSoundMediaBalance(mh,
5789 &balance);
5790 _res = Py_BuildValue("lh",
5791 _rv,
5792 balance);
5793 return _res;
5794 }
5795
5796 static PyObject *Qt_SetSoundMediaBalance(_self, _args)
5797 PyObject *_self;
5798 PyObject *_args;
5799 {
5800 PyObject *_res = NULL;
5801 HandlerError _rv;
5802 MediaHandler mh;
5803 short balance;
5804 if (!PyArg_ParseTuple(_args, "O&h",
5805 CmpInstObj_Convert, &mh,
5806 &balance))
5807 return NULL;
5808 _rv = SetSoundMediaBalance(mh,
5809 balance);
5810 _res = Py_BuildValue("l",
5811 _rv);
5812 return _res;
5813 }
5814
5815 static PyObject *Qt_FindNextText(_self, _args)
5816 PyObject *_self;
5817 PyObject *_args;
5818 {
5819 PyObject *_res = NULL;
5820 ComponentResult _rv;
5821 MediaHandler mh;
5822 Ptr text;
5823 long size;
5824 short findFlags;
5825 TimeValue startTime;
5826 TimeValue foundTime;
5827 TimeValue foundDuration;
5828 long offset;
5829 if (!PyArg_ParseTuple(_args, "O&slhl",
5830 CmpInstObj_Convert, &mh,
5831 &text,
5832 &size,
5833 &findFlags,
5834 &startTime))
5835 return NULL;
5836 _rv = FindNextText(mh,
5837 text,
5838 size,
5839 findFlags,
5840 startTime,
5841 &foundTime,
5842 &foundDuration,
5843 &offset);
5844 _res = Py_BuildValue("llll",
5845 _rv,
5846 foundTime,
5847 foundDuration,
5848 offset);
5849 return _res;
5850 }
5851
5852 static PyObject *Qt_NewMovieFromScrap(_self, _args)
5853 PyObject *_self;
5854 PyObject *_args;
5855 {
5856 PyObject *_res = NULL;
5857 Movie _rv;
5858 long newMovieFlags;
5859 if (!PyArg_ParseTuple(_args, "l",
5860 &newMovieFlags))
5861 return NULL;
5862 _rv = NewMovieFromScrap(newMovieFlags);
5863 _res = Py_BuildValue("O&",
5864 MovieObj_New, _rv);
5865 return _res;
5866 }
5867
5868 static PyObject *Qt_NewTimeBase(_self, _args)
5869 PyObject *_self;
5870 PyObject *_args;
5871 {
5872 PyObject *_res = NULL;
5873 TimeBase _rv;
5874 if (!PyArg_ParseTuple(_args, ""))
5875 return NULL;
5876 _rv = NewTimeBase();
5877 _res = Py_BuildValue("O&",
5878 TimeBaseObj_New, _rv);
5879 return _res;
5880 }
5881
5882 static PyObject *Qt_AlignWindow(_self, _args)
5883 PyObject *_self;
5884 PyObject *_args;
5885 {
5886 PyObject *_res = NULL;
5887 WindowPtr wp;
5888 Boolean front;
5889 if (!PyArg_ParseTuple(_args, "O&b",
5890 WinObj_Convert, &wp,
5891 &front))
5892 return NULL;
5893 AlignWindow(wp,
5894 front,
5895 (Rect *)0,
5896 (ICMAlignmentProcRecordPtr)0);
5897 Py_INCREF(Py_None);
5898 _res = Py_None;
5899 return _res;
5900 }
5901
5902 static PyObject *Qt_DragAlignedWindow(_self, _args)
5903 PyObject *_self;
5904 PyObject *_args;
5905 {
5906 PyObject *_res = NULL;
5907 WindowPtr wp;
5908 Point startPt;
5909 Rect boundsRect;
5910 if (!PyArg_ParseTuple(_args, "O&O&O&",
5911 WinObj_Convert, &wp,
5912 PyMac_GetPoint, &startPt,
5913 PyMac_GetRect, &boundsRect))
5914 return NULL;
5915 DragAlignedWindow(wp,
5916 startPt,
5917 &boundsRect,
5918 (Rect *)0,
5919 (ICMAlignmentProcRecordPtr)0);
5920 Py_INCREF(Py_None);
5921 _res = Py_None;
5922 return _res;
5923 }
5924
5925 static PyMethodDef Qt_methods[] = {
5926 {"EnterMovies", (PyCFunction)Qt_EnterMovies, 1,
5927 "() -> None"},
5928 {"ExitMovies", (PyCFunction)Qt_ExitMovies, 1,
5929 "() -> None"},
5930 {"GetMoviesError", (PyCFunction)Qt_GetMoviesError, 1,
5931 "() -> None"},
5932 {"ClearMoviesStickyError", (PyCFunction)Qt_ClearMoviesStickyError, 1,
5933 "() -> None"},
5934 {"GetMoviesStickyError", (PyCFunction)Qt_GetMoviesStickyError, 1,
5935 "() -> None"},
5936 {"DisposeMatte", (PyCFunction)Qt_DisposeMatte, 1,
5937 "(PixMapHandle theMatte) -> None"},
5938 {"NewMovie", (PyCFunction)Qt_NewMovie, 1,
5939 "(long flags) -> (Movie _rv)"},
5940 {"GetDataHandler", (PyCFunction)Qt_GetDataHandler, 1,
5941 "(Handle dataRef, OSType dataHandlerSubType, long flags) -> (Component _rv)"},
5942 {"PasteHandleIntoMovie", (PyCFunction)Qt_PasteHandleIntoMovie, 1,
5943 "(Handle h, OSType handleType, Movie theMovie, long flags, ComponentInstance userComp) -> None"},
5944 {"TrackTimeToMediaTime", (PyCFunction)Qt_TrackTimeToMediaTime, 1,
5945 "(TimeValue value, Track theTrack) -> (TimeValue _rv)"},
5946 {"NewUserData", (PyCFunction)Qt_NewUserData, 1,
5947 "() -> (UserData theUserData)"},
5948 {"NewUserDataFromHandle", (PyCFunction)Qt_NewUserDataFromHandle, 1,
5949 "(Handle h) -> (UserData theUserData)"},
5950 {"CreateMovieFile", (PyCFunction)Qt_CreateMovieFile, 1,
5951 "(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (short resRefNum, Movie newmovie)"},
5952 {"OpenMovieFile", (PyCFunction)Qt_OpenMovieFile, 1,
5953 "(FSSpec fileSpec, SInt8 permission) -> (short resRefNum)"},
5954 {"CloseMovieFile", (PyCFunction)Qt_CloseMovieFile, 1,
5955 "(short resRefNum) -> None"},
5956 {"DeleteMovieFile", (PyCFunction)Qt_DeleteMovieFile, 1,
5957 "(FSSpec fileSpec) -> None"},
5958 {"NewMovieFromFile", (PyCFunction)Qt_NewMovieFromFile, 1,
5959 "(short resRefNum, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
5960 {"NewMovieFromHandle", (PyCFunction)Qt_NewMovieFromHandle, 1,
5961 "(Handle h, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
5962 {"NewMovieFromDataFork", (PyCFunction)Qt_NewMovieFromDataFork, 1,
5963 "(short fRefNum, long fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
5964 {"RemoveMovieResource", (PyCFunction)Qt_RemoveMovieResource, 1,
5965 "(short resRefNum, short resId) -> None"},
5966 {"GetVideoMediaGraphicsMode", (PyCFunction)Qt_GetVideoMediaGraphicsMode, 1,
5967 "(MediaHandler mh) -> (HandlerError _rv, long graphicsMode, RGBColor opColor)"},
5968 {"SetVideoMediaGraphicsMode", (PyCFunction)Qt_SetVideoMediaGraphicsMode, 1,
5969 "(MediaHandler mh, long graphicsMode, RGBColor opColor) -> (HandlerError _rv)"},
5970 {"GetSoundMediaBalance", (PyCFunction)Qt_GetSoundMediaBalance, 1,
5971 "(MediaHandler mh) -> (HandlerError _rv, short balance)"},
5972 {"SetSoundMediaBalance", (PyCFunction)Qt_SetSoundMediaBalance, 1,
5973 "(MediaHandler mh, short balance) -> (HandlerError _rv)"},
5974 {"FindNextText", (PyCFunction)Qt_FindNextText, 1,
5975 "(MediaHandler mh, Ptr text, long size, short findFlags, TimeValue startTime) -> (ComponentResult _rv, TimeValue foundTime, TimeValue foundDuration, long offset)"},
5976 {"NewMovieFromScrap", (PyCFunction)Qt_NewMovieFromScrap, 1,
5977 "(long newMovieFlags) -> (Movie _rv)"},
5978 {"NewTimeBase", (PyCFunction)Qt_NewTimeBase, 1,
5979 "() -> (TimeBase _rv)"},
5980 {"AlignWindow", (PyCFunction)Qt_AlignWindow, 1,
5981 "(WindowPtr wp, Boolean front) -> None"},
5982 {"DragAlignedWindow", (PyCFunction)Qt_DragAlignedWindow, 1,
5983 "(WindowPtr wp, Point startPt, Rect boundsRect) -> None"},
5984 {NULL, NULL, 0}
5985 };
5986
5987
5988
5989
5990 void initQt()
5991 {
5992 PyObject *m;
5993 PyObject *d;
5994
5995
5996
5997
5998 m = Py_InitModule("Qt", Qt_methods);
5999 d = PyModule_GetDict(m);
6000 Qt_Error = PyMac_GetOSErrException();
6001 if (Qt_Error == NULL ||
6002 PyDict_SetItemString(d, "Error", Qt_Error) != 0)
6003 Py_FatalError("can't initialize Qt.Error");
6004 }
6005
6006 /* ========================= End module Qt ========================== */
6007