Mac/Modules/qt/_Qtmodule.c

   1
   2 /* =========================== Module _Qt =========================== */
   3
   4 #include "Python.h"
   5
   6
   7 #ifndef __LP64__
   8
   9 #include "pymactoolbox.h"
  10
  11 /* Macro to test whether a weak-loaded CFM function exists */
  12 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\
  13     PyErr_SetString(PyExc_NotImplementedError, \
  14     "Not available in this shared library/OS version"); \
  15     return NULL; \
  16     }} while(0)
  17
  18
  19 #include <QuickTime/QuickTime.h>
  20
  21
  22 #ifdef USE_TOOLBOX_OBJECT_GLUE
  23 extern PyObject *_TrackObj_New(Track);
  24 extern int _TrackObj_Convert(PyObject *, Track *);
  25 extern PyObject *_MovieObj_New(Movie);
  26 extern int _MovieObj_Convert(PyObject *, Movie *);
  27 extern PyObject *_MovieCtlObj_New(MovieController);
  28 extern int _MovieCtlObj_Convert(PyObject *, MovieController *);
  29 extern PyObject *_TimeBaseObj_New(TimeBase);
  30 extern int _TimeBaseObj_Convert(PyObject *, TimeBase *);
  31 extern PyObject *_UserDataObj_New(UserData);
  32 extern int _UserDataObj_Convert(PyObject *, UserData *);
  33 extern PyObject *_MediaObj_New(Media);
  34 extern int _MediaObj_Convert(PyObject *, Media *);
  35
  36 #define TrackObj_New _TrackObj_New
  37 #define TrackObj_Convert _TrackObj_Convert
  38 #define MovieObj_New _MovieObj_New
  39 #define MovieObj_Convert _MovieObj_Convert
  40 #define MovieCtlObj_New _MovieCtlObj_New
  41 #define MovieCtlObj_Convert _MovieCtlObj_Convert
  42 #define TimeBaseObj_New _TimeBaseObj_New
  43 #define TimeBaseObj_Convert _TimeBaseObj_Convert
  44 #define UserDataObj_New _UserDataObj_New
  45 #define UserDataObj_Convert _UserDataObj_Convert
  46 #define MediaObj_New _MediaObj_New
  47 #define MediaObj_Convert _MediaObj_Convert
  48 #endif
  49
  50 /* Macro to allow us to GetNextInterestingTime without duration */
  51 #define GetMediaNextInterestingTimeOnly(media, flags, time, rate, rv)                         GetMediaNextInterestingTime(media, flags, time, rate, rv, NULL)
  52
  53 /*
  54 ** Parse/generate time records
  55 */
  56 static PyObject *
  57 QtTimeRecord_New(TimeRecord *itself)
  58 {
  59     if (itself->base)
  60         return Py_BuildValue("O&lO&", PyMac_Buildwide, &itself->value, itself->scale,
  61             TimeBaseObj_New, itself->base);
  62     else
  63         return  Py_BuildValue("O&lO", PyMac_Buildwide, &itself->value, itself->scale,
  64             Py_None);
  65 }
  66
  67 static int
  68 QtTimeRecord_Convert(PyObject *v, TimeRecord *p_itself)
  69 {
  70     PyObject *base = NULL;
  71     if( !PyArg_ParseTuple(v, "O&l|O", PyMac_Getwide, &p_itself->value, &p_itself->scale,
  72                     &base) )
  73         return 0;
  74     if ( base == NULL || base == Py_None )
  75         p_itself->base = NULL;
  76     else
  77         if ( !TimeBaseObj_Convert(base, &p_itself->base) )
  78             return 0;
  79     return 1;
  80 }
  81
  82 static int
  83 QtMusicMIDIPacket_Convert(PyObject *v, MusicMIDIPacket *p_itself)
  84 {
  85     int dummy;
  86
  87     if( !PyArg_ParseTuple(v, "hls#", &p_itself->length, &p_itself->reserved, p_itself->data, dummy) )
  88         return 0;
  89     return 1;
  90 }
  91
  92
  93
  94
  95 static PyObject *Qt_Error;
  96
  97 /* -------------------- Object type IdleManager --------------------- */
  98
  99 PyTypeObject IdleManager_Type;
 100
 101 #define IdleManagerObj_Check(x) ((x)->ob_type == &IdleManager_Type || PyObject_TypeCheck((x), &IdleManager_Type))
 102
 103 typedef struct IdleManagerObject {
 104     PyObject_HEAD
 105     IdleManager ob_itself;
 106 } IdleManagerObject;
 107
 108 PyObject *IdleManagerObj_New(IdleManager itself)
 109 {
 110     IdleManagerObject *it;
 111     if (itself == NULL) {
 112                                     PyErr_SetString(Qt_Error,"Cannot create IdleManager from NULL pointer");
 113                                     return NULL;
 114                             }
 115     it = PyObject_NEW(IdleManagerObject, &IdleManager_Type);
 116     if (it == NULL) return NULL;
 117     it->ob_itself = itself;
 118     return (PyObject *)it;
 119 }
 120
 121 int IdleManagerObj_Convert(PyObject *v, IdleManager *p_itself)
 122 {
 123     if (v == Py_None)
 124     {
 125         *p_itself = NULL;
 126         return 1;
 127     }
 128     if (!IdleManagerObj_Check(v))
 129     {
 130         PyErr_SetString(PyExc_TypeError, "IdleManager required");
 131         return 0;
 132     }
 133     *p_itself = ((IdleManagerObject *)v)->ob_itself;
 134     return 1;
 135 }
 136
 137 static void IdleManagerObj_dealloc(IdleManagerObject *self)
 138 {
 139     /* Cleanup of self->ob_itself goes here */
 140     self->ob_type->tp_free((PyObject *)self);
 141 }
 142
 143 static PyMethodDef IdleManagerObj_methods[] = {
 144     {NULL, NULL, 0}
 145 };
 146
 147 #define IdleManagerObj_getsetlist NULL
 148
 149
 150 #define IdleManagerObj_compare NULL
 151
 152 #define IdleManagerObj_repr NULL
 153
 154 #define IdleManagerObj_hash NULL
 155 #define IdleManagerObj_tp_init 0
 156
 157 #define IdleManagerObj_tp_alloc PyType_GenericAlloc
 158
 159 static PyObject *IdleManagerObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
 160 {
 161     PyObject *_self;
 162     IdleManager itself;
 163     char *kw[] = {"itself", 0};
 164
 165     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, IdleManagerObj_Convert, &itself)) return NULL;
 166     if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
 167     ((IdleManagerObject *)_self)->ob_itself = itself;
 168     return _self;
 169 }
 170
 171 #define IdleManagerObj_tp_free PyObject_Del
 172
 173
 174 PyTypeObject IdleManager_Type = {
 175     PyObject_HEAD_INIT(NULL)
 176     0, /*ob_size*/
 177     "_Qt.IdleManager", /*tp_name*/
 178     sizeof(IdleManagerObject), /*tp_basicsize*/
 179     0, /*tp_itemsize*/
 180     /* methods */
 181     (destructor) IdleManagerObj_dealloc, /*tp_dealloc*/
 182     0, /*tp_print*/
 183     (getattrfunc)0, /*tp_getattr*/
 184     (setattrfunc)0, /*tp_setattr*/
 185     (cmpfunc) IdleManagerObj_compare, /*tp_compare*/
 186     (reprfunc) IdleManagerObj_repr, /*tp_repr*/
 187     (PyNumberMethods *)0, /* tp_as_number */
 188     (PySequenceMethods *)0, /* tp_as_sequence */
 189     (PyMappingMethods *)0, /* tp_as_mapping */
 190     (hashfunc) IdleManagerObj_hash, /*tp_hash*/
 191     0, /*tp_call*/
 192     0, /*tp_str*/
 193     PyObject_GenericGetAttr, /*tp_getattro*/
 194     PyObject_GenericSetAttr, /*tp_setattro */
 195     0, /*tp_as_buffer*/
 196     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
 197     0, /*tp_doc*/
 198     0, /*tp_traverse*/
 199     0, /*tp_clear*/
 200     0, /*tp_richcompare*/
 201     0, /*tp_weaklistoffset*/
 202     0, /*tp_iter*/
 203     0, /*tp_iternext*/
 204     IdleManagerObj_methods, /* tp_methods */
 205     0, /*tp_members*/
 206     IdleManagerObj_getsetlist, /*tp_getset*/
 207     0, /*tp_base*/
 208     0, /*tp_dict*/
 209     0, /*tp_descr_get*/
 210     0, /*tp_descr_set*/
 211     0, /*tp_dictoffset*/
 212     IdleManagerObj_tp_init, /* tp_init */
 213     IdleManagerObj_tp_alloc, /* tp_alloc */
 214     IdleManagerObj_tp_new, /* tp_new */
 215     IdleManagerObj_tp_free, /* tp_free */
 216 };
 217
 218 /* ------------------ End object type IdleManager ------------------- */
 219
 220
 221 /* ------------------ Object type MovieController ------------------- */
 222
 223 PyTypeObject MovieController_Type;
 224
 225 #define MovieCtlObj_Check(x) ((x)->ob_type == &MovieController_Type || PyObject_TypeCheck((x), &MovieController_Type))
 226
 227 typedef struct MovieControllerObject {
 228     PyObject_HEAD
 229     MovieController ob_itself;
 230 } MovieControllerObject;
 231
 232 PyObject *MovieCtlObj_New(MovieController itself)
 233 {
 234     MovieControllerObject *it;
 235     if (itself == NULL) {
 236                                     PyErr_SetString(Qt_Error,"Cannot create MovieController from NULL pointer");
 237                                     return NULL;
 238                             }
 239     it = PyObject_NEW(MovieControllerObject, &MovieController_Type);
 240     if (it == NULL) return NULL;
 241     it->ob_itself = itself;
 242     return (PyObject *)it;
 243 }
 244
 245 int MovieCtlObj_Convert(PyObject *v, MovieController *p_itself)
 246 {
 247     if (v == Py_None)
 248     {
 249         *p_itself = NULL;
 250         return 1;
 251     }
 252     if (!MovieCtlObj_Check(v))
 253     {
 254         PyErr_SetString(PyExc_TypeError, "MovieController required");
 255         return 0;
 256     }
 257     *p_itself = ((MovieControllerObject *)v)->ob_itself;
 258     return 1;
 259 }
 260
 261 static void MovieCtlObj_dealloc(MovieControllerObject *self)
 262 {
 263     if (self->ob_itself) DisposeMovieController(self->ob_itself);
 264     self->ob_type->tp_free((PyObject *)self);
 265 }
 266
 267 static PyObject *MovieCtlObj_MCSetMovie(MovieControllerObject *_self, PyObject *_args)
 268 {
 269     PyObject *_res = NULL;
 270     ComponentResult _rv;
 271     Movie theMovie;
 272     WindowPtr movieWindow;
 273     Point where;
 274 #ifndef MCSetMovie
 275     PyMac_PRECHECK(MCSetMovie);
 276 #endif
 277     if (!PyArg_ParseTuple(_args, "O&O&O&",
 278                           MovieObj_Convert, &theMovie,
 279                           WinObj_Convert, &movieWindow,
 280                           PyMac_GetPoint, &where))
 281         return NULL;
 282     _rv = MCSetMovie(_self->ob_itself,
 283                      theMovie,
 284                      movieWindow,
 285                      where);
 286     _res = Py_BuildValue("l",
 287                          _rv);
 288     return _res;
 289 }
 290
 291 static PyObject *MovieCtlObj_MCGetIndMovie(MovieControllerObject *_self, PyObject *_args)
 292 {
 293     PyObject *_res = NULL;
 294     Movie _rv;
 295     short index;
 296 #ifndef MCGetIndMovie
 297     PyMac_PRECHECK(MCGetIndMovie);
 298 #endif
 299     if (!PyArg_ParseTuple(_args, "h",
 300                           &index))
 301         return NULL;
 302     _rv = MCGetIndMovie(_self->ob_itself,
 303                         index);
 304     _res = Py_BuildValue("O&",
 305                          MovieObj_New, _rv);
 306     return _res;
 307 }
 308
 309 static PyObject *MovieCtlObj_MCRemoveAllMovies(MovieControllerObject *_self, PyObject *_args)
 310 {
 311     PyObject *_res = NULL;
 312     ComponentResult _rv;
 313 #ifndef MCRemoveAllMovies
 314     PyMac_PRECHECK(MCRemoveAllMovies);
 315 #endif
 316     if (!PyArg_ParseTuple(_args, ""))
 317         return NULL;
 318     _rv = MCRemoveAllMovies(_self->ob_itself);
 319     _res = Py_BuildValue("l",
 320                          _rv);
 321     return _res;
 322 }
 323
 324 static PyObject *MovieCtlObj_MCRemoveAMovie(MovieControllerObject *_self, PyObject *_args)
 325 {
 326     PyObject *_res = NULL;
 327     ComponentResult _rv;
 328     Movie m;
 329 #ifndef MCRemoveAMovie
 330     PyMac_PRECHECK(MCRemoveAMovie);
 331 #endif
 332     if (!PyArg_ParseTuple(_args, "O&",
 333                           MovieObj_Convert, &m))
 334         return NULL;
 335     _rv = MCRemoveAMovie(_self->ob_itself,
 336                          m);
 337     _res = Py_BuildValue("l",
 338                          _rv);
 339     return _res;
 340 }
 341
 342 static PyObject *MovieCtlObj_MCRemoveMovie(MovieControllerObject *_self, PyObject *_args)
 343 {
 344     PyObject *_res = NULL;
 345     ComponentResult _rv;
 346 #ifndef MCRemoveMovie
 347     PyMac_PRECHECK(MCRemoveMovie);
 348 #endif
 349     if (!PyArg_ParseTuple(_args, ""))
 350         return NULL;
 351     _rv = MCRemoveMovie(_self->ob_itself);
 352     _res = Py_BuildValue("l",
 353                          _rv);
 354     return _res;
 355 }
 356
 357 static PyObject *MovieCtlObj_MCIsPlayerEvent(MovieControllerObject *_self, PyObject *_args)
 358 {
 359     PyObject *_res = NULL;
 360     ComponentResult _rv;
 361     EventRecord e;
 362 #ifndef MCIsPlayerEvent
 363     PyMac_PRECHECK(MCIsPlayerEvent);
 364 #endif
 365     if (!PyArg_ParseTuple(_args, "O&",
 366                           PyMac_GetEventRecord, &e))
 367         return NULL;
 368     _rv = MCIsPlayerEvent(_self->ob_itself,
 369                           &e);
 370     _res = Py_BuildValue("l",
 371                          _rv);
 372     return _res;
 373 }
 374
 375 static PyObject *MovieCtlObj_MCDoAction(MovieControllerObject *_self, PyObject *_args)
 376 {
 377     PyObject *_res = NULL;
 378     ComponentResult _rv;
 379     short action;
 380     void * params;
 381 #ifndef MCDoAction
 382     PyMac_PRECHECK(MCDoAction);
 383 #endif
 384     if (!PyArg_ParseTuple(_args, "hs",
 385                           &action,
 386                           &params))
 387         return NULL;
 388     _rv = MCDoAction(_self->ob_itself,
 389                      action,
 390                      params);
 391     _res = Py_BuildValue("l",
 392                          _rv);
 393     return _res;
 394 }
 395
 396 static PyObject *MovieCtlObj_MCSetControllerAttached(MovieControllerObject *_self, PyObject *_args)
 397 {
 398     PyObject *_res = NULL;
 399     ComponentResult _rv;
 400     Boolean attach;
 401 #ifndef MCSetControllerAttached
 402     PyMac_PRECHECK(MCSetControllerAttached);
 403 #endif
 404     if (!PyArg_ParseTuple(_args, "b",
 405                           &attach))
 406         return NULL;
 407     _rv = MCSetControllerAttached(_self->ob_itself,
 408                                   attach);
 409     _res = Py_BuildValue("l",
 410                          _rv);
 411     return _res;
 412 }
 413
 414 static PyObject *MovieCtlObj_MCIsControllerAttached(MovieControllerObject *_self, PyObject *_args)
 415 {
 416     PyObject *_res = NULL;
 417     ComponentResult _rv;
 418 #ifndef MCIsControllerAttached
 419     PyMac_PRECHECK(MCIsControllerAttached);
 420 #endif
 421     if (!PyArg_ParseTuple(_args, ""))
 422         return NULL;
 423     _rv = MCIsControllerAttached(_self->ob_itself);
 424     _res = Py_BuildValue("l",
 425                          _rv);
 426     return _res;
 427 }
 428
 429 static PyObject *MovieCtlObj_MCSetControllerPort(MovieControllerObject *_self, PyObject *_args)
 430 {
 431     PyObject *_res = NULL;
 432     ComponentResult _rv;
 433     CGrafPtr gp;
 434 #ifndef MCSetControllerPort
 435     PyMac_PRECHECK(MCSetControllerPort);
 436 #endif
 437     if (!PyArg_ParseTuple(_args, "O&",
 438                           GrafObj_Convert, &gp))
 439         return NULL;
 440     _rv = MCSetControllerPort(_self->ob_itself,
 441                               gp);
 442     _res = Py_BuildValue("l",
 443                          _rv);
 444     return _res;
 445 }
 446
 447 static PyObject *MovieCtlObj_MCGetControllerPort(MovieControllerObject *_self, PyObject *_args)
 448 {
 449     PyObject *_res = NULL;
 450     CGrafPtr _rv;
 451 #ifndef MCGetControllerPort
 452     PyMac_PRECHECK(MCGetControllerPort);
 453 #endif
 454     if (!PyArg_ParseTuple(_args, ""))
 455         return NULL;
 456     _rv = MCGetControllerPort(_self->ob_itself);
 457     _res = Py_BuildValue("O&",
 458                          GrafObj_New, _rv);
 459     return _res;
 460 }
 461
 462 static PyObject *MovieCtlObj_MCSetVisible(MovieControllerObject *_self, PyObject *_args)
 463 {
 464     PyObject *_res = NULL;
 465     ComponentResult _rv;
 466     Boolean visible;
 467 #ifndef MCSetVisible
 468     PyMac_PRECHECK(MCSetVisible);
 469 #endif
 470     if (!PyArg_ParseTuple(_args, "b",
 471                           &visible))
 472         return NULL;
 473     _rv = MCSetVisible(_self->ob_itself,
 474                        visible);
 475     _res = Py_BuildValue("l",
 476                          _rv);
 477     return _res;
 478 }
 479
 480 static PyObject *MovieCtlObj_MCGetVisible(MovieControllerObject *_self, PyObject *_args)
 481 {
 482     PyObject *_res = NULL;
 483     ComponentResult _rv;
 484 #ifndef MCGetVisible
 485     PyMac_PRECHECK(MCGetVisible);
 486 #endif
 487     if (!PyArg_ParseTuple(_args, ""))
 488         return NULL;
 489     _rv = MCGetVisible(_self->ob_itself);
 490     _res = Py_BuildValue("l",
 491                          _rv);
 492     return _res;
 493 }
 494
 495 static PyObject *MovieCtlObj_MCGetControllerBoundsRect(MovieControllerObject *_self, PyObject *_args)
 496 {
 497     PyObject *_res = NULL;
 498     ComponentResult _rv;
 499     Rect bounds;
 500 #ifndef MCGetControllerBoundsRect
 501     PyMac_PRECHECK(MCGetControllerBoundsRect);
 502 #endif
 503     if (!PyArg_ParseTuple(_args, ""))
 504         return NULL;
 505     _rv = MCGetControllerBoundsRect(_self->ob_itself,
 506                                     &bounds);
 507     _res = Py_BuildValue("lO&",
 508                          _rv,
 509                          PyMac_BuildRect, &bounds);
 510     return _res;
 511 }
 512
 513 static PyObject *MovieCtlObj_MCSetControllerBoundsRect(MovieControllerObject *_self, PyObject *_args)
 514 {
 515     PyObject *_res = NULL;
 516     ComponentResult _rv;
 517     Rect bounds;
 518 #ifndef MCSetControllerBoundsRect
 519     PyMac_PRECHECK(MCSetControllerBoundsRect);
 520 #endif
 521     if (!PyArg_ParseTuple(_args, "O&",
 522                           PyMac_GetRect, &bounds))
 523         return NULL;
 524     _rv = MCSetControllerBoundsRect(_self->ob_itself,
 525                                     &bounds);
 526     _res = Py_BuildValue("l",
 527                          _rv);
 528     return _res;
 529 }
 530
 531 static PyObject *MovieCtlObj_MCGetControllerBoundsRgn(MovieControllerObject *_self, PyObject *_args)
 532 {
 533     PyObject *_res = NULL;
 534     RgnHandle _rv;
 535 #ifndef MCGetControllerBoundsRgn
 536     PyMac_PRECHECK(MCGetControllerBoundsRgn);
 537 #endif
 538     if (!PyArg_ParseTuple(_args, ""))
 539         return NULL;
 540     _rv = MCGetControllerBoundsRgn(_self->ob_itself);
 541     _res = Py_BuildValue("O&",
 542                          ResObj_New, _rv);
 543     return _res;
 544 }
 545
 546 static PyObject *MovieCtlObj_MCGetWindowRgn(MovieControllerObject *_self, PyObject *_args)
 547 {
 548     PyObject *_res = NULL;
 549     RgnHandle _rv;
 550     WindowPtr w;
 551 #ifndef MCGetWindowRgn
 552     PyMac_PRECHECK(MCGetWindowRgn);
 553 #endif
 554     if (!PyArg_ParseTuple(_args, "O&",
 555                           WinObj_Convert, &w))
 556         return NULL;
 557     _rv = MCGetWindowRgn(_self->ob_itself,
 558                          w);
 559     _res = Py_BuildValue("O&",
 560                          ResObj_New, _rv);
 561     return _res;
 562 }
 563
 564 static PyObject *MovieCtlObj_MCMovieChanged(MovieControllerObject *_self, PyObject *_args)
 565 {
 566     PyObject *_res = NULL;
 567     ComponentResult _rv;
 568     Movie m;
 569 #ifndef MCMovieChanged
 570     PyMac_PRECHECK(MCMovieChanged);
 571 #endif
 572     if (!PyArg_ParseTuple(_args, "O&",
 573                           MovieObj_Convert, &m))
 574         return NULL;
 575     _rv = MCMovieChanged(_self->ob_itself,
 576                          m);
 577     _res = Py_BuildValue("l",
 578                          _rv);
 579     return _res;
 580 }
 581
 582 static PyObject *MovieCtlObj_MCSetDuration(MovieControllerObject *_self, PyObject *_args)
 583 {
 584     PyObject *_res = NULL;
 585     ComponentResult _rv;
 586     TimeValue duration;
 587 #ifndef MCSetDuration
 588     PyMac_PRECHECK(MCSetDuration);
 589 #endif
 590     if (!PyArg_ParseTuple(_args, "l",
 591                           &duration))
 592         return NULL;
 593     _rv = MCSetDuration(_self->ob_itself,
 594                         duration);
 595     _res = Py_BuildValue("l",
 596                          _rv);
 597     return _res;
 598 }
 599
 600 static PyObject *MovieCtlObj_MCGetCurrentTime(MovieControllerObject *_self, PyObject *_args)
 601 {
 602     PyObject *_res = NULL;
 603     TimeValue _rv;
 604     TimeScale scale;
 605 #ifndef MCGetCurrentTime
 606     PyMac_PRECHECK(MCGetCurrentTime);
 607 #endif
 608     if (!PyArg_ParseTuple(_args, ""))
 609         return NULL;
 610     _rv = MCGetCurrentTime(_self->ob_itself,
 611                            &scale);
 612     _res = Py_BuildValue("ll",
 613                          _rv,
 614                          scale);
 615     return _res;
 616 }
 617
 618 static PyObject *MovieCtlObj_MCNewAttachedController(MovieControllerObject *_self, PyObject *_args)
 619 {
 620     PyObject *_res = NULL;
 621     ComponentResult _rv;
 622     Movie theMovie;
 623     WindowPtr w;
 624     Point where;
 625 #ifndef MCNewAttachedController
 626     PyMac_PRECHECK(MCNewAttachedController);
 627 #endif
 628     if (!PyArg_ParseTuple(_args, "O&O&O&",
 629                           MovieObj_Convert, &theMovie,
 630                           WinObj_Convert, &w,
 631                           PyMac_GetPoint, &where))
 632         return NULL;
 633     _rv = MCNewAttachedController(_self->ob_itself,
 634                                   theMovie,
 635                                   w,
 636                                   where);
 637     _res = Py_BuildValue("l",
 638                          _rv);
 639     return _res;
 640 }
 641
 642 static PyObject *MovieCtlObj_MCDraw(MovieControllerObject *_self, PyObject *_args)
 643 {
 644     PyObject *_res = NULL;
 645     ComponentResult _rv;
 646     WindowPtr w;
 647 #ifndef MCDraw
 648     PyMac_PRECHECK(MCDraw);
 649 #endif
 650     if (!PyArg_ParseTuple(_args, "O&",
 651                           WinObj_Convert, &w))
 652         return NULL;
 653     _rv = MCDraw(_self->ob_itself,
 654                  w);
 655     _res = Py_BuildValue("l",
 656                          _rv);
 657     return _res;
 658 }
 659
 660 static PyObject *MovieCtlObj_MCActivate(MovieControllerObject *_self, PyObject *_args)
 661 {
 662     PyObject *_res = NULL;
 663     ComponentResult _rv;
 664     WindowPtr w;
 665     Boolean activate;
 666 #ifndef MCActivate
 667     PyMac_PRECHECK(MCActivate);
 668 #endif
 669     if (!PyArg_ParseTuple(_args, "O&b",
 670                           WinObj_Convert, &w,
 671                           &activate))
 672         return NULL;
 673     _rv = MCActivate(_self->ob_itself,
 674                      w,
 675                      activate);
 676     _res = Py_BuildValue("l",
 677                          _rv);
 678     return _res;
 679 }
 680
 681 static PyObject *MovieCtlObj_MCIdle(MovieControllerObject *_self, PyObject *_args)
 682 {
 683     PyObject *_res = NULL;
 684     ComponentResult _rv;
 685 #ifndef MCIdle
 686     PyMac_PRECHECK(MCIdle);
 687 #endif
 688     if (!PyArg_ParseTuple(_args, ""))
 689         return NULL;
 690     _rv = MCIdle(_self->ob_itself);
 691     _res = Py_BuildValue("l",
 692                          _rv);
 693     return _res;
 694 }
 695
 696 static PyObject *MovieCtlObj_MCKey(MovieControllerObject *_self, PyObject *_args)
 697 {
 698     PyObject *_res = NULL;
 699     ComponentResult _rv;
 700     SInt8 key;
 701     long modifiers;
 702 #ifndef MCKey
 703     PyMac_PRECHECK(MCKey);
 704 #endif
 705     if (!PyArg_ParseTuple(_args, "bl",
 706                           &key,
 707                           &modifiers))
 708         return NULL;
 709     _rv = MCKey(_self->ob_itself,
 710                 key,
 711                 modifiers);
 712     _res = Py_BuildValue("l",
 713                          _rv);
 714     return _res;
 715 }
 716
 717 static PyObject *MovieCtlObj_MCClick(MovieControllerObject *_self, PyObject *_args)
 718 {
 719     PyObject *_res = NULL;
 720     ComponentResult _rv;
 721     WindowPtr w;
 722     Point where;
 723     long when;
 724     long modifiers;
 725 #ifndef MCClick
 726     PyMac_PRECHECK(MCClick);
 727 #endif
 728     if (!PyArg_ParseTuple(_args, "O&O&ll",
 729                           WinObj_Convert, &w,
 730                           PyMac_GetPoint, &where,
 731                           &when,
 732                           &modifiers))
 733         return NULL;
 734     _rv = MCClick(_self->ob_itself,
 735                   w,
 736                   where,
 737                   when,
 738                   modifiers);
 739     _res = Py_BuildValue("l",
 740                          _rv);
 741     return _res;
 742 }
 743
 744 static PyObject *MovieCtlObj_MCEnableEditing(MovieControllerObject *_self, PyObject *_args)
 745 {
 746     PyObject *_res = NULL;
 747     ComponentResult _rv;
 748     Boolean enabled;
 749 #ifndef MCEnableEditing
 750     PyMac_PRECHECK(MCEnableEditing);
 751 #endif
 752     if (!PyArg_ParseTuple(_args, "b",
 753                           &enabled))
 754         return NULL;
 755     _rv = MCEnableEditing(_self->ob_itself,
 756                           enabled);
 757     _res = Py_BuildValue("l",
 758                          _rv);
 759     return _res;
 760 }
 761
 762 static PyObject *MovieCtlObj_MCIsEditingEnabled(MovieControllerObject *_self, PyObject *_args)
 763 {
 764     PyObject *_res = NULL;
 765     long _rv;
 766 #ifndef MCIsEditingEnabled
 767     PyMac_PRECHECK(MCIsEditingEnabled);
 768 #endif
 769     if (!PyArg_ParseTuple(_args, ""))
 770         return NULL;
 771     _rv = MCIsEditingEnabled(_self->ob_itself);
 772     _res = Py_BuildValue("l",
 773                          _rv);
 774     return _res;
 775 }
 776
 777 static PyObject *MovieCtlObj_MCCopy(MovieControllerObject *_self, PyObject *_args)
 778 {
 779     PyObject *_res = NULL;
 780     Movie _rv;
 781 #ifndef MCCopy
 782     PyMac_PRECHECK(MCCopy);
 783 #endif
 784     if (!PyArg_ParseTuple(_args, ""))
 785         return NULL;
 786     _rv = MCCopy(_self->ob_itself);
 787     _res = Py_BuildValue("O&",
 788                          MovieObj_New, _rv);
 789     return _res;
 790 }
 791
 792 static PyObject *MovieCtlObj_MCCut(MovieControllerObject *_self, PyObject *_args)
 793 {
 794     PyObject *_res = NULL;
 795     Movie _rv;
 796 #ifndef MCCut
 797     PyMac_PRECHECK(MCCut);
 798 #endif
 799     if (!PyArg_ParseTuple(_args, ""))
 800         return NULL;
 801     _rv = MCCut(_self->ob_itself);
 802     _res = Py_BuildValue("O&",
 803                          MovieObj_New, _rv);
 804     return _res;
 805 }
 806
 807 static PyObject *MovieCtlObj_MCPaste(MovieControllerObject *_self, PyObject *_args)
 808 {
 809     PyObject *_res = NULL;
 810     ComponentResult _rv;
 811     Movie srcMovie;
 812 #ifndef MCPaste
 813     PyMac_PRECHECK(MCPaste);
 814 #endif
 815     if (!PyArg_ParseTuple(_args, "O&",
 816                           MovieObj_Convert, &srcMovie))
 817         return NULL;
 818     _rv = MCPaste(_self->ob_itself,
 819                   srcMovie);
 820     _res = Py_BuildValue("l",
 821                          _rv);
 822     return _res;
 823 }
 824
 825 static PyObject *MovieCtlObj_MCClear(MovieControllerObject *_self, PyObject *_args)
 826 {
 827     PyObject *_res = NULL;
 828     ComponentResult _rv;
 829 #ifndef MCClear
 830     PyMac_PRECHECK(MCClear);
 831 #endif
 832     if (!PyArg_ParseTuple(_args, ""))
 833         return NULL;
 834     _rv = MCClear(_self->ob_itself);
 835     _res = Py_BuildValue("l",
 836                          _rv);
 837     return _res;
 838 }
 839
 840 static PyObject *MovieCtlObj_MCUndo(MovieControllerObject *_self, PyObject *_args)
 841 {
 842     PyObject *_res = NULL;
 843     ComponentResult _rv;
 844 #ifndef MCUndo
 845     PyMac_PRECHECK(MCUndo);
 846 #endif
 847     if (!PyArg_ParseTuple(_args, ""))
 848         return NULL;
 849     _rv = MCUndo(_self->ob_itself);
 850     _res = Py_BuildValue("l",
 851                          _rv);
 852     return _res;
 853 }
 854
 855 static PyObject *MovieCtlObj_MCPositionController(MovieControllerObject *_self, PyObject *_args)
 856 {
 857     PyObject *_res = NULL;
 858     ComponentResult _rv;
 859     Rect movieRect;
 860     Rect controllerRect;
 861     long someFlags;
 862 #ifndef MCPositionController
 863     PyMac_PRECHECK(MCPositionController);
 864 #endif
 865     if (!PyArg_ParseTuple(_args, "O&O&l",
 866                           PyMac_GetRect, &movieRect,
 867                           PyMac_GetRect, &controllerRect,
 868                           &someFlags))
 869         return NULL;
 870     _rv = MCPositionController(_self->ob_itself,
 871                                &movieRect,
 872                                &controllerRect,
 873                                someFlags);
 874     _res = Py_BuildValue("l",
 875                          _rv);
 876     return _res;
 877 }
 878
 879 static PyObject *MovieCtlObj_MCGetControllerInfo(MovieControllerObject *_self, PyObject *_args)
 880 {
 881     PyObject *_res = NULL;
 882     ComponentResult _rv;
 883     long someFlags;
 884 #ifndef MCGetControllerInfo
 885     PyMac_PRECHECK(MCGetControllerInfo);
 886 #endif
 887     if (!PyArg_ParseTuple(_args, ""))
 888         return NULL;
 889     _rv = MCGetControllerInfo(_self->ob_itself,
 890                               &someFlags);
 891     _res = Py_BuildValue("ll",
 892                          _rv,
 893                          someFlags);
 894     return _res;
 895 }
 896
 897 static PyObject *MovieCtlObj_MCSetClip(MovieControllerObject *_self, PyObject *_args)
 898 {
 899     PyObject *_res = NULL;
 900     ComponentResult _rv;
 901     RgnHandle theClip;
 902     RgnHandle movieClip;
 903 #ifndef MCSetClip
 904     PyMac_PRECHECK(MCSetClip);
 905 #endif
 906     if (!PyArg_ParseTuple(_args, "O&O&",
 907                           ResObj_Convert, &theClip,
 908                           ResObj_Convert, &movieClip))
 909         return NULL;
 910     _rv = MCSetClip(_self->ob_itself,
 911                     theClip,
 912                     movieClip);
 913     _res = Py_BuildValue("l",
 914                          _rv);
 915     return _res;
 916 }
 917
 918 static PyObject *MovieCtlObj_MCGetClip(MovieControllerObject *_self, PyObject *_args)
 919 {
 920     PyObject *_res = NULL;
 921     ComponentResult _rv;
 922     RgnHandle theClip;
 923     RgnHandle movieClip;
 924 #ifndef MCGetClip
 925     PyMac_PRECHECK(MCGetClip);
 926 #endif
 927     if (!PyArg_ParseTuple(_args, ""))
 928         return NULL;
 929     _rv = MCGetClip(_self->ob_itself,
 930                     &theClip,
 931                     &movieClip);
 932     _res = Py_BuildValue("lO&O&",
 933                          _rv,
 934                          ResObj_New, theClip,
 935                          ResObj_New, movieClip);
 936     return _res;
 937 }
 938
 939 static PyObject *MovieCtlObj_MCDrawBadge(MovieControllerObject *_self, PyObject *_args)
 940 {
 941     PyObject *_res = NULL;
 942     ComponentResult _rv;
 943     RgnHandle movieRgn;
 944     RgnHandle badgeRgn;
 945 #ifndef MCDrawBadge
 946     PyMac_PRECHECK(MCDrawBadge);
 947 #endif
 948     if (!PyArg_ParseTuple(_args, "O&",
 949                           ResObj_Convert, &movieRgn))
 950         return NULL;
 951     _rv = MCDrawBadge(_self->ob_itself,
 952                       movieRgn,
 953                       &badgeRgn);
 954     _res = Py_BuildValue("lO&",
 955                          _rv,
 956                          ResObj_New, badgeRgn);
 957     return _res;
 958 }
 959
 960 static PyObject *MovieCtlObj_MCSetUpEditMenu(MovieControllerObject *_self, PyObject *_args)
 961 {
 962     PyObject *_res = NULL;
 963     ComponentResult _rv;
 964     long modifiers;
 965     MenuHandle mh;
 966 #ifndef MCSetUpEditMenu
 967     PyMac_PRECHECK(MCSetUpEditMenu);
 968 #endif
 969     if (!PyArg_ParseTuple(_args, "lO&",
 970                           &modifiers,
 971                           MenuObj_Convert, &mh))
 972         return NULL;
 973     _rv = MCSetUpEditMenu(_self->ob_itself,
 974                           modifiers,
 975                           mh);
 976     _res = Py_BuildValue("l",
 977                          _rv);
 978     return _res;
 979 }
 980
 981 static PyObject *MovieCtlObj_MCGetMenuString(MovieControllerObject *_self, PyObject *_args)
 982 {
 983     PyObject *_res = NULL;
 984     ComponentResult _rv;
 985     long modifiers;
 986     short item;
 987     Str255 aString;
 988 #ifndef MCGetMenuString
 989     PyMac_PRECHECK(MCGetMenuString);
 990 #endif
 991     if (!PyArg_ParseTuple(_args, "lhO&",
 992                           &modifiers,
 993                           &item,
 994                           PyMac_GetStr255, aString))
 995         return NULL;
 996     _rv = MCGetMenuString(_self->ob_itself,
 997                           modifiers,
 998                           item,
 999                           aString);
1000     _res = Py_BuildValue("l",
1001                          _rv);
1002     return _res;
1003 }
1004
1005 static PyObject *MovieCtlObj_MCPtInController(MovieControllerObject *_self, PyObject *_args)
1006 {
1007     PyObject *_res = NULL;
1008     ComponentResult _rv;
1009     Point thePt;
1010     Boolean inController;
1011 #ifndef MCPtInController
1012     PyMac_PRECHECK(MCPtInController);
1013 #endif
1014     if (!PyArg_ParseTuple(_args, "O&",
1015                           PyMac_GetPoint, &thePt))
1016         return NULL;
1017     _rv = MCPtInController(_self->ob_itself,
1018                            thePt,
1019                            &inController);
1020     _res = Py_BuildValue("lb",
1021                          _rv,
1022                          inController);
1023     return _res;
1024 }
1025
1026 static PyObject *MovieCtlObj_MCInvalidate(MovieControllerObject *_self, PyObject *_args)
1027 {
1028     PyObject *_res = NULL;
1029     ComponentResult _rv;
1030     WindowPtr w;
1031     RgnHandle invalidRgn;
1032 #ifndef MCInvalidate
1033     PyMac_PRECHECK(MCInvalidate);
1034 #endif
1035     if (!PyArg_ParseTuple(_args, "O&O&",
1036                           WinObj_Convert, &w,
1037                           ResObj_Convert, &invalidRgn))
1038         return NULL;
1039     _rv = MCInvalidate(_self->ob_itself,
1040                        w,
1041                        invalidRgn);
1042     _res = Py_BuildValue("l",
1043                          _rv);
1044     return _res;
1045 }
1046
1047 static PyObject *MovieCtlObj_MCAdjustCursor(MovieControllerObject *_self, PyObject *_args)
1048 {
1049     PyObject *_res = NULL;
1050     ComponentResult _rv;
1051     WindowPtr w;
1052     Point where;
1053     long modifiers;
1054 #ifndef MCAdjustCursor
1055     PyMac_PRECHECK(MCAdjustCursor);
1056 #endif
1057     if (!PyArg_ParseTuple(_args, "O&O&l",
1058                           WinObj_Convert, &w,
1059                           PyMac_GetPoint, &where,
1060                           &modifiers))
1061         return NULL;
1062     _rv = MCAdjustCursor(_self->ob_itself,
1063                          w,
1064                          where,
1065                          modifiers);
1066     _res = Py_BuildValue("l",
1067                          _rv);
1068     return _res;
1069 }
1070
1071 static PyObject *MovieCtlObj_MCGetInterfaceElement(MovieControllerObject *_self, PyObject *_args)
1072 {
1073     PyObject *_res = NULL;
1074     ComponentResult _rv;
1075     MCInterfaceElement whichElement;
1076     void * element;
1077 #ifndef MCGetInterfaceElement
1078     PyMac_PRECHECK(MCGetInterfaceElement);
1079 #endif
1080     if (!PyArg_ParseTuple(_args, "ls",
1081                           &whichElement,
1082                           &element))
1083         return NULL;
1084     _rv = MCGetInterfaceElement(_self->ob_itself,
1085                                 whichElement,
1086                                 element);
1087     _res = Py_BuildValue("l",
1088                          _rv);
1089     return _res;
1090 }
1091
1092 static PyObject *MovieCtlObj_MCAddMovieSegment(MovieControllerObject *_self, PyObject *_args)
1093 {
1094     PyObject *_res = NULL;
1095     ComponentResult _rv;
1096     Movie srcMovie;
1097     Boolean scaled;
1098 #ifndef MCAddMovieSegment
1099     PyMac_PRECHECK(MCAddMovieSegment);
1100 #endif
1101     if (!PyArg_ParseTuple(_args, "O&b",
1102                           MovieObj_Convert, &srcMovie,
1103                           &scaled))
1104         return NULL;
1105     _rv = MCAddMovieSegment(_self->ob_itself,
1106                             srcMovie,
1107                             scaled);
1108     _res = Py_BuildValue("l",
1109                          _rv);
1110     return _res;
1111 }
1112
1113 static PyObject *MovieCtlObj_MCTrimMovieSegment(MovieControllerObject *_self, PyObject *_args)
1114 {
1115     PyObject *_res = NULL;
1116     ComponentResult _rv;
1117 #ifndef MCTrimMovieSegment
1118     PyMac_PRECHECK(MCTrimMovieSegment);
1119 #endif
1120     if (!PyArg_ParseTuple(_args, ""))
1121         return NULL;
1122     _rv = MCTrimMovieSegment(_self->ob_itself);
1123     _res = Py_BuildValue("l",
1124                          _rv);
1125     return _res;
1126 }
1127
1128 static PyObject *MovieCtlObj_MCSetIdleManager(MovieControllerObject *_self, PyObject *_args)
1129 {
1130     PyObject *_res = NULL;
1131     ComponentResult _rv;
1132     IdleManager im;
1133 #ifndef MCSetIdleManager
1134     PyMac_PRECHECK(MCSetIdleManager);
1135 #endif
1136     if (!PyArg_ParseTuple(_args, "O&",
1137                           IdleManagerObj_Convert, &im))
1138         return NULL;
1139     _rv = MCSetIdleManager(_self->ob_itself,
1140                            im);
1141     _res = Py_BuildValue("l",
1142                          _rv);
1143     return _res;
1144 }
1145
1146 static PyObject *MovieCtlObj_MCSetControllerCapabilities(MovieControllerObject *_self, PyObject *_args)
1147 {
1148     PyObject *_res = NULL;
1149     ComponentResult _rv;
1150     long flags;
1151     long flagsMask;
1152 #ifndef MCSetControllerCapabilities
1153     PyMac_PRECHECK(MCSetControllerCapabilities);
1154 #endif
1155     if (!PyArg_ParseTuple(_args, "ll",
1156                           &flags,
1157                           &flagsMask))
1158         return NULL;
1159     _rv = MCSetControllerCapabilities(_self->ob_itself,
1160                                       flags,
1161                                       flagsMask);
1162     _res = Py_BuildValue("l",
1163                          _rv);
1164     return _res;
1165 }
1166
1167 static PyMethodDef MovieCtlObj_methods[] = {
1168     {"MCSetMovie", (PyCFunction)MovieCtlObj_MCSetMovie, 1,
1169      PyDoc_STR("(Movie theMovie, WindowPtr movieWindow, Point where) -> (ComponentResult _rv)")},
1170     {"MCGetIndMovie", (PyCFunction)MovieCtlObj_MCGetIndMovie, 1,
1171      PyDoc_STR("(short index) -> (Movie _rv)")},
1172     {"MCRemoveAllMovies", (PyCFunction)MovieCtlObj_MCRemoveAllMovies, 1,
1173      PyDoc_STR("() -> (ComponentResult _rv)")},
1174     {"MCRemoveAMovie", (PyCFunction)MovieCtlObj_MCRemoveAMovie, 1,
1175      PyDoc_STR("(Movie m) -> (ComponentResult _rv)")},
1176     {"MCRemoveMovie", (PyCFunction)MovieCtlObj_MCRemoveMovie, 1,
1177      PyDoc_STR("() -> (ComponentResult _rv)")},
1178     {"MCIsPlayerEvent", (PyCFunction)MovieCtlObj_MCIsPlayerEvent, 1,
1179      PyDoc_STR("(EventRecord e) -> (ComponentResult _rv)")},
1180     {"MCDoAction", (PyCFunction)MovieCtlObj_MCDoAction, 1,
1181      PyDoc_STR("(short action, void * params) -> (ComponentResult _rv)")},
1182     {"MCSetControllerAttached", (PyCFunction)MovieCtlObj_MCSetControllerAttached, 1,
1183      PyDoc_STR("(Boolean attach) -> (ComponentResult _rv)")},
1184     {"MCIsControllerAttached", (PyCFunction)MovieCtlObj_MCIsControllerAttached, 1,
1185      PyDoc_STR("() -> (ComponentResult _rv)")},
1186     {"MCSetControllerPort", (PyCFunction)MovieCtlObj_MCSetControllerPort, 1,
1187      PyDoc_STR("(CGrafPtr gp) -> (ComponentResult _rv)")},
1188     {"MCGetControllerPort", (PyCFunction)MovieCtlObj_MCGetControllerPort, 1,
1189      PyDoc_STR("() -> (CGrafPtr _rv)")},
1190     {"MCSetVisible", (PyCFunction)MovieCtlObj_MCSetVisible, 1,
1191      PyDoc_STR("(Boolean visible) -> (ComponentResult _rv)")},
1192     {"MCGetVisible", (PyCFunction)MovieCtlObj_MCGetVisible, 1,
1193      PyDoc_STR("() -> (ComponentResult _rv)")},
1194     {"MCGetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRect, 1,
1195      PyDoc_STR("() -> (ComponentResult _rv, Rect bounds)")},
1196     {"MCSetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCSetControllerBoundsRect, 1,
1197      PyDoc_STR("(Rect bounds) -> (ComponentResult _rv)")},
1198     {"MCGetControllerBoundsRgn", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRgn, 1,
1199      PyDoc_STR("() -> (RgnHandle _rv)")},
1200     {"MCGetWindowRgn", (PyCFunction)MovieCtlObj_MCGetWindowRgn, 1,
1201      PyDoc_STR("(WindowPtr w) -> (RgnHandle _rv)")},
1202     {"MCMovieChanged", (PyCFunction)MovieCtlObj_MCMovieChanged, 1,
1203      PyDoc_STR("(Movie m) -> (ComponentResult _rv)")},
1204     {"MCSetDuration", (PyCFunction)MovieCtlObj_MCSetDuration, 1,
1205      PyDoc_STR("(TimeValue duration) -> (ComponentResult _rv)")},
1206     {"MCGetCurrentTime", (PyCFunction)MovieCtlObj_MCGetCurrentTime, 1,
1207      PyDoc_STR("() -> (TimeValue _rv, TimeScale scale)")},
1208     {"MCNewAttachedController", (PyCFunction)MovieCtlObj_MCNewAttachedController, 1,
1209      PyDoc_STR("(Movie theMovie, WindowPtr w, Point where) -> (ComponentResult _rv)")},
1210     {"MCDraw", (PyCFunction)MovieCtlObj_MCDraw, 1,
1211      PyDoc_STR("(WindowPtr w) -> (ComponentResult _rv)")},
1212     {"MCActivate", (PyCFunction)MovieCtlObj_MCActivate, 1,
1213      PyDoc_STR("(WindowPtr w, Boolean activate) -> (ComponentResult _rv)")},
1214     {"MCIdle", (PyCFunction)MovieCtlObj_MCIdle, 1,
1215      PyDoc_STR("() -> (ComponentResult _rv)")},
1216     {"MCKey", (PyCFunction)MovieCtlObj_MCKey, 1,
1217      PyDoc_STR("(SInt8 key, long modifiers) -> (ComponentResult _rv)")},
1218     {"MCClick", (PyCFunction)MovieCtlObj_MCClick, 1,
1219      PyDoc_STR("(WindowPtr w, Point where, long when, long modifiers) -> (ComponentResult _rv)")},
1220     {"MCEnableEditing", (PyCFunction)MovieCtlObj_MCEnableEditing, 1,
1221      PyDoc_STR("(Boolean enabled) -> (ComponentResult _rv)")},
1222     {"MCIsEditingEnabled", (PyCFunction)MovieCtlObj_MCIsEditingEnabled, 1,
1223      PyDoc_STR("() -> (long _rv)")},
1224     {"MCCopy", (PyCFunction)MovieCtlObj_MCCopy, 1,
1225      PyDoc_STR("() -> (Movie _rv)")},
1226     {"MCCut", (PyCFunction)MovieCtlObj_MCCut, 1,
1227      PyDoc_STR("() -> (Movie _rv)")},
1228     {"MCPaste", (PyCFunction)MovieCtlObj_MCPaste, 1,
1229      PyDoc_STR("(Movie srcMovie) -> (ComponentResult _rv)")},
1230     {"MCClear", (PyCFunction)MovieCtlObj_MCClear, 1,
1231      PyDoc_STR("() -> (ComponentResult _rv)")},
1232     {"MCUndo", (PyCFunction)MovieCtlObj_MCUndo, 1,
1233      PyDoc_STR("() -> (ComponentResult _rv)")},
1234     {"MCPositionController", (PyCFunction)MovieCtlObj_MCPositionController, 1,
1235      PyDoc_STR("(Rect movieRect, Rect controllerRect, long someFlags) -> (ComponentResult _rv)")},
1236     {"MCGetControllerInfo", (PyCFunction)MovieCtlObj_MCGetControllerInfo, 1,
1237      PyDoc_STR("() -> (ComponentResult _rv, long someFlags)")},
1238     {"MCSetClip", (PyCFunction)MovieCtlObj_MCSetClip, 1,
1239      PyDoc_STR("(RgnHandle theClip, RgnHandle movieClip) -> (ComponentResult _rv)")},
1240     {"MCGetClip", (PyCFunction)MovieCtlObj_MCGetClip, 1,
1241      PyDoc_STR("() -> (ComponentResult _rv, RgnHandle theClip, RgnHandle movieClip)")},
1242     {"MCDrawBadge", (PyCFunction)MovieCtlObj_MCDrawBadge, 1,
1243      PyDoc_STR("(RgnHandle movieRgn) -> (ComponentResult _rv, RgnHandle badgeRgn)")},
1244     {"MCSetUpEditMenu", (PyCFunction)MovieCtlObj_MCSetUpEditMenu, 1,
1245      PyDoc_STR("(long modifiers, MenuHandle mh) -> (ComponentResult _rv)")},
1246     {"MCGetMenuString", (PyCFunction)MovieCtlObj_MCGetMenuString, 1,
1247      PyDoc_STR("(long modifiers, short item, Str255 aString) -> (ComponentResult _rv)")},
1248     {"MCPtInController", (PyCFunction)MovieCtlObj_MCPtInController, 1,
1249      PyDoc_STR("(Point thePt) -> (ComponentResult _rv, Boolean inController)")},
1250     {"MCInvalidate", (PyCFunction)MovieCtlObj_MCInvalidate, 1,
1251      PyDoc_STR("(WindowPtr w, RgnHandle invalidRgn) -> (ComponentResult _rv)")},
1252     {"MCAdjustCursor", (PyCFunction)MovieCtlObj_MCAdjustCursor, 1,
1253      PyDoc_STR("(WindowPtr w, Point where, long modifiers) -> (ComponentResult _rv)")},
1254     {"MCGetInterfaceElement", (PyCFunction)MovieCtlObj_MCGetInterfaceElement, 1,
1255      PyDoc_STR("(MCInterfaceElement whichElement, void * element) -> (ComponentResult _rv)")},
1256     {"MCAddMovieSegment", (PyCFunction)MovieCtlObj_MCAddMovieSegment, 1,
1257      PyDoc_STR("(Movie srcMovie, Boolean scaled) -> (ComponentResult _rv)")},
1258     {"MCTrimMovieSegment", (PyCFunction)MovieCtlObj_MCTrimMovieSegment, 1,
1259      PyDoc_STR("() -> (ComponentResult _rv)")},
1260     {"MCSetIdleManager", (PyCFunction)MovieCtlObj_MCSetIdleManager, 1,
1261      PyDoc_STR("(IdleManager im) -> (ComponentResult _rv)")},
1262     {"MCSetControllerCapabilities", (PyCFunction)MovieCtlObj_MCSetControllerCapabilities, 1,
1263      PyDoc_STR("(long flags, long flagsMask) -> (ComponentResult _rv)")},
1264     {NULL, NULL, 0}
1265 };
1266
1267 #define MovieCtlObj_getsetlist NULL
1268
1269
1270 #define MovieCtlObj_compare NULL
1271
1272 #define MovieCtlObj_repr NULL
1273
1274 #define MovieCtlObj_hash NULL
1275 #define MovieCtlObj_tp_init 0
1276
1277 #define MovieCtlObj_tp_alloc PyType_GenericAlloc
1278
1279 static PyObject *MovieCtlObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
1280 {
1281     PyObject *_self;
1282     MovieController itself;
1283     char *kw[] = {"itself", 0};
1284
1285     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, MovieCtlObj_Convert, &itself)) return NULL;
1286     if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
1287     ((MovieControllerObject *)_self)->ob_itself = itself;
1288     return _self;
1289 }
1290
1291 #define MovieCtlObj_tp_free PyObject_Del
1292
1293
1294 PyTypeObject MovieController_Type = {
1295     PyObject_HEAD_INIT(NULL)
1296     0, /*ob_size*/
1297     "_Qt.MovieController", /*tp_name*/
1298     sizeof(MovieControllerObject), /*tp_basicsize*/
1299     0, /*tp_itemsize*/
1300     /* methods */
1301     (destructor) MovieCtlObj_dealloc, /*tp_dealloc*/
1302     0, /*tp_print*/
1303     (getattrfunc)0, /*tp_getattr*/
1304     (setattrfunc)0, /*tp_setattr*/
1305     (cmpfunc) MovieCtlObj_compare, /*tp_compare*/
1306     (reprfunc) MovieCtlObj_repr, /*tp_repr*/
1307     (PyNumberMethods *)0, /* tp_as_number */
1308     (PySequenceMethods *)0, /* tp_as_sequence */
1309     (PyMappingMethods *)0, /* tp_as_mapping */
1310     (hashfunc) MovieCtlObj_hash, /*tp_hash*/
1311     0, /*tp_call*/
1312     0, /*tp_str*/
1313     PyObject_GenericGetAttr, /*tp_getattro*/
1314     PyObject_GenericSetAttr, /*tp_setattro */
1315     0, /*tp_as_buffer*/
1316     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
1317     0, /*tp_doc*/
1318     0, /*tp_traverse*/
1319     0, /*tp_clear*/
1320     0, /*tp_richcompare*/
1321     0, /*tp_weaklistoffset*/
1322     0, /*tp_iter*/
1323     0, /*tp_iternext*/
1324     MovieCtlObj_methods, /* tp_methods */
1325     0, /*tp_members*/
1326     MovieCtlObj_getsetlist, /*tp_getset*/
1327     0, /*tp_base*/
1328     0, /*tp_dict*/
1329     0, /*tp_descr_get*/
1330     0, /*tp_descr_set*/
1331     0, /*tp_dictoffset*/
1332     MovieCtlObj_tp_init, /* tp_init */
1333     MovieCtlObj_tp_alloc, /* tp_alloc */
1334     MovieCtlObj_tp_new, /* tp_new */
1335     MovieCtlObj_tp_free, /* tp_free */
1336 };
1337
1338 /* ---------------- End object type MovieController ----------------- */
1339
1340
1341 /* ---------------------- Object type TimeBase ---------------------- */
1342
1343 PyTypeObject TimeBase_Type;
1344
1345 #define TimeBaseObj_Check(x) ((x)->ob_type == &TimeBase_Type || PyObject_TypeCheck((x), &TimeBase_Type))
1346
1347 typedef struct TimeBaseObject {
1348     PyObject_HEAD
1349     TimeBase ob_itself;
1350 } TimeBaseObject;
1351
1352 PyObject *TimeBaseObj_New(TimeBase itself)
1353 {
1354     TimeBaseObject *it;
1355     if (itself == NULL) {
1356                                     PyErr_SetString(Qt_Error,"Cannot create TimeBase from NULL pointer");
1357                                     return NULL;
1358                             }
1359     it = PyObject_NEW(TimeBaseObject, &TimeBase_Type);
1360     if (it == NULL) return NULL;
1361     it->ob_itself = itself;
1362     return (PyObject *)it;
1363 }
1364
1365 int TimeBaseObj_Convert(PyObject *v, TimeBase *p_itself)
1366 {
1367     if (v == Py_None)
1368     {
1369         *p_itself = NULL;
1370         return 1;
1371     }
1372     if (!TimeBaseObj_Check(v))
1373     {
1374         PyErr_SetString(PyExc_TypeError, "TimeBase required");
1375         return 0;
1376     }
1377     *p_itself = ((TimeBaseObject *)v)->ob_itself;
1378     return 1;
1379 }
1380
1381 static void TimeBaseObj_dealloc(TimeBaseObject *self)
1382 {
1383     /* Cleanup of self->ob_itself goes here */
1384     self->ob_type->tp_free((PyObject *)self);
1385 }
1386
1387 static PyObject *TimeBaseObj_DisposeTimeBase(TimeBaseObject *_self, PyObject *_args)
1388 {
1389     PyObject *_res = NULL;
1390 #ifndef DisposeTimeBase
1391     PyMac_PRECHECK(DisposeTimeBase);
1392 #endif
1393     if (!PyArg_ParseTuple(_args, ""))
1394         return NULL;
1395     DisposeTimeBase(_self->ob_itself);
1396     Py_INCREF(Py_None);
1397     _res = Py_None;
1398     return _res;
1399 }
1400
1401 static PyObject *TimeBaseObj_GetTimeBaseTime(TimeBaseObject *_self, PyObject *_args)
1402 {
1403     PyObject *_res = NULL;
1404     TimeValue _rv;
1405     TimeScale s;
1406     TimeRecord tr;
1407 #ifndef GetTimeBaseTime
1408     PyMac_PRECHECK(GetTimeBaseTime);
1409 #endif
1410     if (!PyArg_ParseTuple(_args, "l",
1411                           &s))
1412         return NULL;
1413     _rv = GetTimeBaseTime(_self->ob_itself,
1414                           s,
1415                           &tr);
1416     _res = Py_BuildValue("lO&",
1417                          _rv,
1418                          QtTimeRecord_New, &tr);
1419     return _res;
1420 }
1421
1422 static PyObject *TimeBaseObj_SetTimeBaseTime(TimeBaseObject *_self, PyObject *_args)
1423 {
1424     PyObject *_res = NULL;
1425     TimeRecord tr;
1426 #ifndef SetTimeBaseTime
1427     PyMac_PRECHECK(SetTimeBaseTime);
1428 #endif
1429     if (!PyArg_ParseTuple(_args, "O&",
1430                           QtTimeRecord_Convert, &tr))
1431         return NULL;
1432     SetTimeBaseTime(_self->ob_itself,
1433                     &tr);
1434     Py_INCREF(Py_None);
1435     _res = Py_None;
1436     return _res;
1437 }
1438
1439 static PyObject *TimeBaseObj_SetTimeBaseValue(TimeBaseObject *_self, PyObject *_args)
1440 {
1441     PyObject *_res = NULL;
1442     TimeValue t;
1443     TimeScale s;
1444 #ifndef SetTimeBaseValue
1445     PyMac_PRECHECK(SetTimeBaseValue);
1446 #endif
1447     if (!PyArg_ParseTuple(_args, "ll",
1448                           &t,
1449                           &s))
1450         return NULL;
1451     SetTimeBaseValue(_self->ob_itself,
1452                      t,
1453                      s);
1454     Py_INCREF(Py_None);
1455     _res = Py_None;
1456     return _res;
1457 }
1458
1459 static PyObject *TimeBaseObj_GetTimeBaseRate(TimeBaseObject *_self, PyObject *_args)
1460 {
1461     PyObject *_res = NULL;
1462     Fixed _rv;
1463 #ifndef GetTimeBaseRate
1464     PyMac_PRECHECK(GetTimeBaseRate);
1465 #endif
1466     if (!PyArg_ParseTuple(_args, ""))
1467         return NULL;
1468     _rv = GetTimeBaseRate(_self->ob_itself);
1469     _res = Py_BuildValue("O&",
1470                          PyMac_BuildFixed, _rv);
1471     return _res;
1472 }
1473
1474 static PyObject *TimeBaseObj_SetTimeBaseRate(TimeBaseObject *_self, PyObject *_args)
1475 {
1476     PyObject *_res = NULL;
1477     Fixed r;
1478 #ifndef SetTimeBaseRate
1479     PyMac_PRECHECK(SetTimeBaseRate);
1480 #endif
1481     if (!PyArg_ParseTuple(_args, "O&",
1482                           PyMac_GetFixed, &r))
1483         return NULL;
1484     SetTimeBaseRate(_self->ob_itself,
1485                     r);
1486     Py_INCREF(Py_None);
1487     _res = Py_None;
1488     return _res;
1489 }
1490
1491 static PyObject *TimeBaseObj_GetTimeBaseStartTime(TimeBaseObject *_self, PyObject *_args)
1492 {
1493     PyObject *_res = NULL;
1494     TimeValue _rv;
1495     TimeScale s;
1496     TimeRecord tr;
1497 #ifndef GetTimeBaseStartTime
1498     PyMac_PRECHECK(GetTimeBaseStartTime);
1499 #endif
1500     if (!PyArg_ParseTuple(_args, "l",
1501                           &s))
1502         return NULL;
1503     _rv = GetTimeBaseStartTime(_self->ob_itself,
1504                                s,
1505                                &tr);
1506     _res = Py_BuildValue("lO&",
1507                          _rv,
1508                          QtTimeRecord_New, &tr);
1509     return _res;
1510 }
1511
1512 static PyObject *TimeBaseObj_SetTimeBaseStartTime(TimeBaseObject *_self, PyObject *_args)
1513 {
1514     PyObject *_res = NULL;
1515     TimeRecord tr;
1516 #ifndef SetTimeBaseStartTime
1517     PyMac_PRECHECK(SetTimeBaseStartTime);
1518 #endif
1519     if (!PyArg_ParseTuple(_args, "O&",
1520                           QtTimeRecord_Convert, &tr))
1521         return NULL;
1522     SetTimeBaseStartTime(_self->ob_itself,
1523                          &tr);
1524     Py_INCREF(Py_None);
1525     _res = Py_None;
1526     return _res;
1527 }
1528
1529 static PyObject *TimeBaseObj_GetTimeBaseStopTime(TimeBaseObject *_self, PyObject *_args)
1530 {
1531     PyObject *_res = NULL;
1532     TimeValue _rv;
1533     TimeScale s;
1534     TimeRecord tr;
1535 #ifndef GetTimeBaseStopTime
1536     PyMac_PRECHECK(GetTimeBaseStopTime);
1537 #endif
1538     if (!PyArg_ParseTuple(_args, "l",
1539                           &s))
1540         return NULL;
1541     _rv = GetTimeBaseStopTime(_self->ob_itself,
1542                               s,
1543                               &tr);
1544     _res = Py_BuildValue("lO&",
1545                          _rv,
1546                          QtTimeRecord_New, &tr);
1547     return _res;
1548 }
1549
1550 static PyObject *TimeBaseObj_SetTimeBaseStopTime(TimeBaseObject *_self, PyObject *_args)
1551 {
1552     PyObject *_res = NULL;
1553     TimeRecord tr;
1554 #ifndef SetTimeBaseStopTime
1555     PyMac_PRECHECK(SetTimeBaseStopTime);
1556 #endif
1557     if (!PyArg_ParseTuple(_args, "O&",
1558                           QtTimeRecord_Convert, &tr))
1559         return NULL;
1560     SetTimeBaseStopTime(_self->ob_itself,
1561                         &tr);
1562     Py_INCREF(Py_None);
1563     _res = Py_None;
1564     return _res;
1565 }
1566
1567 static PyObject *TimeBaseObj_GetTimeBaseFlags(TimeBaseObject *_self, PyObject *_args)
1568 {
1569     PyObject *_res = NULL;
1570     long _rv;
1571 #ifndef GetTimeBaseFlags
1572     PyMac_PRECHECK(GetTimeBaseFlags);
1573 #endif
1574     if (!PyArg_ParseTuple(_args, ""))
1575         return NULL;
1576     _rv = GetTimeBaseFlags(_self->ob_itself);
1577     _res = Py_BuildValue("l",
1578                          _rv);
1579     return _res;
1580 }
1581
1582 static PyObject *TimeBaseObj_SetTimeBaseFlags(TimeBaseObject *_self, PyObject *_args)
1583 {
1584     PyObject *_res = NULL;
1585     long timeBaseFlags;
1586 #ifndef SetTimeBaseFlags
1587     PyMac_PRECHECK(SetTimeBaseFlags);
1588 #endif
1589     if (!PyArg_ParseTuple(_args, "l",
1590                           &timeBaseFlags))
1591         return NULL;
1592     SetTimeBaseFlags(_self->ob_itself,
1593                      timeBaseFlags);
1594     Py_INCREF(Py_None);
1595     _res = Py_None;
1596     return _res;
1597 }
1598
1599 static PyObject *TimeBaseObj_SetTimeBaseMasterTimeBase(TimeBaseObject *_self, PyObject *_args)
1600 {
1601     PyObject *_res = NULL;
1602     TimeBase master;
1603     TimeRecord slaveZero;
1604 #ifndef SetTimeBaseMasterTimeBase
1605     PyMac_PRECHECK(SetTimeBaseMasterTimeBase);
1606 #endif
1607     if (!PyArg_ParseTuple(_args, "O&O&",
1608                           TimeBaseObj_Convert, &master,
1609                           QtTimeRecord_Convert, &slaveZero))
1610         return NULL;
1611     SetTimeBaseMasterTimeBase(_self->ob_itself,
1612                               master,
1613                               &slaveZero);
1614     Py_INCREF(Py_None);
1615     _res = Py_None;
1616     return _res;
1617 }
1618
1619 static PyObject *TimeBaseObj_GetTimeBaseMasterTimeBase(TimeBaseObject *_self, PyObject *_args)
1620 {
1621     PyObject *_res = NULL;
1622     TimeBase _rv;
1623 #ifndef GetTimeBaseMasterTimeBase
1624     PyMac_PRECHECK(GetTimeBaseMasterTimeBase);
1625 #endif
1626     if (!PyArg_ParseTuple(_args, ""))
1627         return NULL;
1628     _rv = GetTimeBaseMasterTimeBase(_self->ob_itself);
1629     _res = Py_BuildValue("O&",
1630                          TimeBaseObj_New, _rv);
1631     return _res;
1632 }
1633
1634 static PyObject *TimeBaseObj_SetTimeBaseMasterClock(TimeBaseObject *_self, PyObject *_args)
1635 {
1636     PyObject *_res = NULL;
1637     Component clockMeister;
1638     TimeRecord slaveZero;
1639 #ifndef SetTimeBaseMasterClock
1640     PyMac_PRECHECK(SetTimeBaseMasterClock);
1641 #endif
1642     if (!PyArg_ParseTuple(_args, "O&O&",
1643                           CmpObj_Convert, &clockMeister,
1644                           QtTimeRecord_Convert, &slaveZero))
1645         return NULL;
1646     SetTimeBaseMasterClock(_self->ob_itself,
1647                            clockMeister,
1648                            &slaveZero);
1649     Py_INCREF(Py_None);
1650     _res = Py_None;
1651     return _res;
1652 }
1653
1654 static PyObject *TimeBaseObj_GetTimeBaseMasterClock(TimeBaseObject *_self, PyObject *_args)
1655 {
1656     PyObject *_res = NULL;
1657     ComponentInstance _rv;
1658 #ifndef GetTimeBaseMasterClock
1659     PyMac_PRECHECK(GetTimeBaseMasterClock);
1660 #endif
1661     if (!PyArg_ParseTuple(_args, ""))
1662         return NULL;
1663     _rv = GetTimeBaseMasterClock(_self->ob_itself);
1664     _res = Py_BuildValue("O&",
1665                          CmpInstObj_New, _rv);
1666     return _res;
1667 }
1668
1669 static PyObject *TimeBaseObj_GetTimeBaseStatus(TimeBaseObject *_self, PyObject *_args)
1670 {
1671     PyObject *_res = NULL;
1672     long _rv;
1673     TimeRecord unpinnedTime;
1674 #ifndef GetTimeBaseStatus
1675     PyMac_PRECHECK(GetTimeBaseStatus);
1676 #endif
1677     if (!PyArg_ParseTuple(_args, ""))
1678         return NULL;
1679     _rv = GetTimeBaseStatus(_self->ob_itself,
1680                             &unpinnedTime);
1681     _res = Py_BuildValue("lO&",
1682                          _rv,
1683                          QtTimeRecord_New, &unpinnedTime);
1684     return _res;
1685 }
1686
1687 static PyObject *TimeBaseObj_SetTimeBaseZero(TimeBaseObject *_self, PyObject *_args)
1688 {
1689     PyObject *_res = NULL;
1690     TimeRecord zero;
1691 #ifndef SetTimeBaseZero
1692     PyMac_PRECHECK(SetTimeBaseZero);
1693 #endif
1694     if (!PyArg_ParseTuple(_args, "O&",
1695                           QtTimeRecord_Convert, &zero))
1696         return NULL;
1697     SetTimeBaseZero(_self->ob_itself,
1698                     &zero);
1699     Py_INCREF(Py_None);
1700     _res = Py_None;
1701     return _res;
1702 }
1703
1704 static PyObject *TimeBaseObj_GetTimeBaseEffectiveRate(TimeBaseObject *_self, PyObject *_args)
1705 {
1706     PyObject *_res = NULL;
1707     Fixed _rv;
1708 #ifndef GetTimeBaseEffectiveRate
1709     PyMac_PRECHECK(GetTimeBaseEffectiveRate);
1710 #endif
1711     if (!PyArg_ParseTuple(_args, ""))
1712         return NULL;
1713     _rv = GetTimeBaseEffectiveRate(_self->ob_itself);
1714     _res = Py_BuildValue("O&",
1715                          PyMac_BuildFixed, _rv);
1716     return _res;
1717 }
1718
1719 static PyMethodDef TimeBaseObj_methods[] = {
1720     {"DisposeTimeBase", (PyCFunction)TimeBaseObj_DisposeTimeBase, 1,
1721      PyDoc_STR("() -> None")},
1722     {"GetTimeBaseTime", (PyCFunction)TimeBaseObj_GetTimeBaseTime, 1,
1723      PyDoc_STR("(TimeScale s) -> (TimeValue _rv, TimeRecord tr)")},
1724     {"SetTimeBaseTime", (PyCFunction)TimeBaseObj_SetTimeBaseTime, 1,
1725      PyDoc_STR("(TimeRecord tr) -> None")},
1726     {"SetTimeBaseValue", (PyCFunction)TimeBaseObj_SetTimeBaseValue, 1,
1727      PyDoc_STR("(TimeValue t, TimeScale s) -> None")},
1728     {"GetTimeBaseRate", (PyCFunction)TimeBaseObj_GetTimeBaseRate, 1,
1729      PyDoc_STR("() -> (Fixed _rv)")},
1730     {"SetTimeBaseRate", (PyCFunction)TimeBaseObj_SetTimeBaseRate, 1,
1731      PyDoc_STR("(Fixed r) -> None")},
1732     {"GetTimeBaseStartTime", (PyCFunction)TimeBaseObj_GetTimeBaseStartTime, 1,
1733      PyDoc_STR("(TimeScale s) -> (TimeValue _rv, TimeRecord tr)")},
1734     {"SetTimeBaseStartTime", (PyCFunction)TimeBaseObj_SetTimeBaseStartTime, 1,
1735      PyDoc_STR("(TimeRecord tr) -> None")},
1736     {"GetTimeBaseStopTime", (PyCFunction)TimeBaseObj_GetTimeBaseStopTime, 1,
1737      PyDoc_STR("(TimeScale s) -> (TimeValue _rv, TimeRecord tr)")},
1738     {"SetTimeBaseStopTime", (PyCFunction)TimeBaseObj_SetTimeBaseStopTime, 1,
1739      PyDoc_STR("(TimeRecord tr) -> None")},
1740     {"GetTimeBaseFlags", (PyCFunction)TimeBaseObj_GetTimeBaseFlags, 1,
1741      PyDoc_STR("() -> (long _rv)")},
1742     {"SetTimeBaseFlags", (PyCFunction)TimeBaseObj_SetTimeBaseFlags, 1,
1743      PyDoc_STR("(long timeBaseFlags) -> None")},
1744     {"SetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_SetTimeBaseMasterTimeBase, 1,
1745      PyDoc_STR("(TimeBase master, TimeRecord slaveZero) -> None")},
1746     {"GetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_GetTimeBaseMasterTimeBase, 1,
1747      PyDoc_STR("() -> (TimeBase _rv)")},
1748     {"SetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_SetTimeBaseMasterClock, 1,
1749      PyDoc_STR("(Component clockMeister, TimeRecord slaveZero) -> None")},
1750     {"GetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_GetTimeBaseMasterClock, 1,
1751      PyDoc_STR("() -> (ComponentInstance _rv)")},
1752     {"GetTimeBaseStatus", (PyCFunction)TimeBaseObj_GetTimeBaseStatus, 1,
1753      PyDoc_STR("() -> (long _rv, TimeRecord unpinnedTime)")},
1754     {"SetTimeBaseZero", (PyCFunction)TimeBaseObj_SetTimeBaseZero, 1,
1755      PyDoc_STR("(TimeRecord zero) -> None")},
1756     {"GetTimeBaseEffectiveRate", (PyCFunction)TimeBaseObj_GetTimeBaseEffectiveRate, 1,
1757      PyDoc_STR("() -> (Fixed _rv)")},
1758     {NULL, NULL, 0}
1759 };
1760
1761 #define TimeBaseObj_getsetlist NULL
1762
1763
1764 #define TimeBaseObj_compare NULL
1765
1766 #define TimeBaseObj_repr NULL
1767
1768 #define TimeBaseObj_hash NULL
1769 #define TimeBaseObj_tp_init 0
1770
1771 #define TimeBaseObj_tp_alloc PyType_GenericAlloc
1772
1773 static PyObject *TimeBaseObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
1774 {
1775     PyObject *_self;
1776     TimeBase itself;
1777     char *kw[] = {"itself", 0};
1778
1779     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, TimeBaseObj_Convert, &itself)) return NULL;
1780     if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
1781     ((TimeBaseObject *)_self)->ob_itself = itself;
1782     return _self;
1783 }
1784
1785 #define TimeBaseObj_tp_free PyObject_Del
1786
1787
1788 PyTypeObject TimeBase_Type = {
1789     PyObject_HEAD_INIT(NULL)
1790     0, /*ob_size*/
1791     "_Qt.TimeBase", /*tp_name*/
1792     sizeof(TimeBaseObject), /*tp_basicsize*/
1793     0, /*tp_itemsize*/
1794     /* methods */
1795     (destructor) TimeBaseObj_dealloc, /*tp_dealloc*/
1796     0, /*tp_print*/
1797     (getattrfunc)0, /*tp_getattr*/
1798     (setattrfunc)0, /*tp_setattr*/
1799     (cmpfunc) TimeBaseObj_compare, /*tp_compare*/
1800     (reprfunc) TimeBaseObj_repr, /*tp_repr*/
1801     (PyNumberMethods *)0, /* tp_as_number */
1802     (PySequenceMethods *)0, /* tp_as_sequence */
1803     (PyMappingMethods *)0, /* tp_as_mapping */
1804     (hashfunc) TimeBaseObj_hash, /*tp_hash*/
1805     0, /*tp_call*/
1806     0, /*tp_str*/
1807     PyObject_GenericGetAttr, /*tp_getattro*/
1808     PyObject_GenericSetAttr, /*tp_setattro */
1809     0, /*tp_as_buffer*/
1810     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
1811     0, /*tp_doc*/
1812     0, /*tp_traverse*/
1813     0, /*tp_clear*/
1814     0, /*tp_richcompare*/
1815     0, /*tp_weaklistoffset*/
1816     0, /*tp_iter*/
1817     0, /*tp_iternext*/
1818     TimeBaseObj_methods, /* tp_methods */
1819     0, /*tp_members*/
1820     TimeBaseObj_getsetlist, /*tp_getset*/
1821     0, /*tp_base*/
1822     0, /*tp_dict*/
1823     0, /*tp_descr_get*/
1824     0, /*tp_descr_set*/
1825     0, /*tp_dictoffset*/
1826     TimeBaseObj_tp_init, /* tp_init */
1827     TimeBaseObj_tp_alloc, /* tp_alloc */
1828     TimeBaseObj_tp_new, /* tp_new */
1829     TimeBaseObj_tp_free, /* tp_free */
1830 };
1831
1832 /* -------------------- End object type TimeBase -------------------- */
1833
1834
1835 /* ---------------------- Object type UserData ---------------------- */
1836
1837 PyTypeObject UserData_Type;
1838
1839 #define UserDataObj_Check(x) ((x)->ob_type == &UserData_Type || PyObject_TypeCheck((x), &UserData_Type))
1840
1841 typedef struct UserDataObject {
1842     PyObject_HEAD
1843     UserData ob_itself;
1844 } UserDataObject;
1845
1846 PyObject *UserDataObj_New(UserData itself)
1847 {
1848     UserDataObject *it;
1849     if (itself == NULL) {
1850                                     PyErr_SetString(Qt_Error,"Cannot create UserData from NULL pointer");
1851                                     return NULL;
1852                             }
1853     it = PyObject_NEW(UserDataObject, &UserData_Type);
1854     if (it == NULL) return NULL;
1855     it->ob_itself = itself;
1856     return (PyObject *)it;
1857 }
1858
1859 int UserDataObj_Convert(PyObject *v, UserData *p_itself)
1860 {
1861     if (v == Py_None)
1862     {
1863         *p_itself = NULL;
1864         return 1;
1865     }
1866     if (!UserDataObj_Check(v))
1867     {
1868         PyErr_SetString(PyExc_TypeError, "UserData required");
1869         return 0;
1870     }
1871     *p_itself = ((UserDataObject *)v)->ob_itself;
1872     return 1;
1873 }
1874
1875 static void UserDataObj_dealloc(UserDataObject *self)
1876 {
1877     if (self->ob_itself) DisposeUserData(self->ob_itself);
1878     self->ob_type->tp_free((PyObject *)self);
1879 }
1880
1881 static PyObject *UserDataObj_GetUserData(UserDataObject *_self, PyObject *_args)
1882 {
1883     PyObject *_res = NULL;
1884     OSErr _err;
1885     Handle data;
1886     OSType udType;
1887     long index;
1888 #ifndef GetUserData
1889     PyMac_PRECHECK(GetUserData);
1890 #endif
1891     if (!PyArg_ParseTuple(_args, "O&O&l",
1892                           ResObj_Convert, &data,
1893                           PyMac_GetOSType, &udType,
1894                           &index))
1895         return NULL;
1896     _err = GetUserData(_self->ob_itself,
1897                        data,
1898                        udType,
1899                        index);
1900     if (_err != noErr) return PyMac_Error(_err);
1901     Py_INCREF(Py_None);
1902     _res = Py_None;
1903     return _res;
1904 }
1905
1906 static PyObject *UserDataObj_AddUserData(UserDataObject *_self, PyObject *_args)
1907 {
1908     PyObject *_res = NULL;
1909     OSErr _err;
1910     Handle data;
1911     OSType udType;
1912 #ifndef AddUserData
1913     PyMac_PRECHECK(AddUserData);
1914 #endif
1915     if (!PyArg_ParseTuple(_args, "O&O&",
1916                           ResObj_Convert, &data,
1917                           PyMac_GetOSType, &udType))
1918         return NULL;
1919     _err = AddUserData(_self->ob_itself,
1920                        data,
1921                        udType);
1922     if (_err != noErr) return PyMac_Error(_err);
1923     Py_INCREF(Py_None);
1924     _res = Py_None;
1925     return _res;
1926 }
1927
1928 static PyObject *UserDataObj_RemoveUserData(UserDataObject *_self, PyObject *_args)
1929 {
1930     PyObject *_res = NULL;
1931     OSErr _err;
1932     OSType udType;
1933     long index;
1934 #ifndef RemoveUserData
1935     PyMac_PRECHECK(RemoveUserData);
1936 #endif
1937     if (!PyArg_ParseTuple(_args, "O&l",
1938                           PyMac_GetOSType, &udType,
1939                           &index))
1940         return NULL;
1941     _err = RemoveUserData(_self->ob_itself,
1942                           udType,
1943                           index);
1944     if (_err != noErr) return PyMac_Error(_err);
1945     Py_INCREF(Py_None);
1946     _res = Py_None;
1947     return _res;
1948 }
1949
1950 static PyObject *UserDataObj_CountUserDataType(UserDataObject *_self, PyObject *_args)
1951 {
1952     PyObject *_res = NULL;
1953     short _rv;
1954     OSType udType;
1955 #ifndef CountUserDataType
1956     PyMac_PRECHECK(CountUserDataType);
1957 #endif
1958     if (!PyArg_ParseTuple(_args, "O&",
1959                           PyMac_GetOSType, &udType))
1960         return NULL;
1961     _rv = CountUserDataType(_self->ob_itself,
1962                             udType);
1963     _res = Py_BuildValue("h",
1964                          _rv);
1965     return _res;
1966 }
1967
1968 static PyObject *UserDataObj_GetNextUserDataType(UserDataObject *_self, PyObject *_args)
1969 {
1970     PyObject *_res = NULL;
1971     long _rv;
1972     OSType udType;
1973 #ifndef GetNextUserDataType
1974     PyMac_PRECHECK(GetNextUserDataType);
1975 #endif
1976     if (!PyArg_ParseTuple(_args, "O&",
1977                           PyMac_GetOSType, &udType))
1978         return NULL;
1979     _rv = GetNextUserDataType(_self->ob_itself,
1980                               udType);
1981     _res = Py_BuildValue("l",
1982                          _rv);
1983     return _res;
1984 }
1985
1986 static PyObject *UserDataObj_AddUserDataText(UserDataObject *_self, PyObject *_args)
1987 {
1988     PyObject *_res = NULL;
1989     OSErr _err;
1990     Handle data;
1991     OSType udType;
1992     long index;
1993     short itlRegionTag;
1994 #ifndef AddUserDataText
1995     PyMac_PRECHECK(AddUserDataText);
1996 #endif
1997     if (!PyArg_ParseTuple(_args, "O&O&lh",
1998                           ResObj_Convert, &data,
1999                           PyMac_GetOSType, &udType,
2000                           &index,
2001                           &itlRegionTag))
2002         return NULL;
2003     _err = AddUserDataText(_self->ob_itself,
2004                            data,
2005                            udType,
2006                            index,
2007                            itlRegionTag);
2008     if (_err != noErr) return PyMac_Error(_err);
2009     Py_INCREF(Py_None);
2010     _res = Py_None;
2011     return _res;
2012 }
2013
2014 static PyObject *UserDataObj_GetUserDataText(UserDataObject *_self, PyObject *_args)
2015 {
2016     PyObject *_res = NULL;
2017     OSErr _err;
2018     Handle data;
2019     OSType udType;
2020     long index;
2021     short itlRegionTag;
2022 #ifndef GetUserDataText
2023     PyMac_PRECHECK(GetUserDataText);
2024 #endif
2025     if (!PyArg_ParseTuple(_args, "O&O&lh",
2026                           ResObj_Convert, &data,
2027                           PyMac_GetOSType, &udType,
2028                           &index,
2029                           &itlRegionTag))
2030         return NULL;
2031     _err = GetUserDataText(_self->ob_itself,
2032                            data,
2033                            udType,
2034                            index,
2035                            itlRegionTag);
2036     if (_err != noErr) return PyMac_Error(_err);
2037     Py_INCREF(Py_None);
2038     _res = Py_None;
2039     return _res;
2040 }
2041
2042 static PyObject *UserDataObj_RemoveUserDataText(UserDataObject *_self, PyObject *_args)
2043 {
2044     PyObject *_res = NULL;
2045     OSErr _err;
2046     OSType udType;
2047     long index;
2048     short itlRegionTag;
2049 #ifndef RemoveUserDataText
2050     PyMac_PRECHECK(RemoveUserDataText);
2051 #endif
2052     if (!PyArg_ParseTuple(_args, "O&lh",
2053                           PyMac_GetOSType, &udType,
2054                           &index,
2055                           &itlRegionTag))
2056         return NULL;
2057     _err = RemoveUserDataText(_self->ob_itself,
2058                               udType,
2059                               index,
2060                               itlRegionTag);
2061     if (_err != noErr) return PyMac_Error(_err);
2062     Py_INCREF(Py_None);
2063     _res = Py_None;
2064     return _res;
2065 }
2066
2067 static PyObject *UserDataObj_PutUserDataIntoHandle(UserDataObject *_self, PyObject *_args)
2068 {
2069     PyObject *_res = NULL;
2070     OSErr _err;
2071     Handle h;
2072 #ifndef PutUserDataIntoHandle
2073     PyMac_PRECHECK(PutUserDataIntoHandle);
2074 #endif
2075     if (!PyArg_ParseTuple(_args, "O&",
2076                           ResObj_Convert, &h))
2077         return NULL;
2078     _err = PutUserDataIntoHandle(_self->ob_itself,
2079                                  h);
2080     if (_err != noErr) return PyMac_Error(_err);
2081     Py_INCREF(Py_None);
2082     _res = Py_None;
2083     return _res;
2084 }
2085
2086 static PyObject *UserDataObj_CopyUserData(UserDataObject *_self, PyObject *_args)
2087 {
2088     PyObject *_res = NULL;
2089     OSErr _err;
2090     UserData dstUserData;
2091     OSType copyRule;
2092 #ifndef CopyUserData
2093     PyMac_PRECHECK(CopyUserData);
2094 #endif
2095     if (!PyArg_ParseTuple(_args, "O&O&",
2096                           UserDataObj_Convert, &dstUserData,
2097                           PyMac_GetOSType, &copyRule))
2098         return NULL;
2099     _err = CopyUserData(_self->ob_itself,
2100                         dstUserData,
2101                         copyRule);
2102     if (_err != noErr) return PyMac_Error(_err);
2103     Py_INCREF(Py_None);
2104     _res = Py_None;
2105     return _res;
2106 }
2107
2108 static PyMethodDef UserDataObj_methods[] = {
2109     {"GetUserData", (PyCFunction)UserDataObj_GetUserData, 1,
2110      PyDoc_STR("(Handle data, OSType udType, long index) -> None")},
2111     {"AddUserData", (PyCFunction)UserDataObj_AddUserData, 1,
2112      PyDoc_STR("(Handle data, OSType udType) -> None")},
2113     {"RemoveUserData", (PyCFunction)UserDataObj_RemoveUserData, 1,
2114      PyDoc_STR("(OSType udType, long index) -> None")},
2115     {"CountUserDataType", (PyCFunction)UserDataObj_CountUserDataType, 1,
2116      PyDoc_STR("(OSType udType) -> (short _rv)")},
2117     {"GetNextUserDataType", (PyCFunction)UserDataObj_GetNextUserDataType, 1,
2118      PyDoc_STR("(OSType udType) -> (long _rv)")},
2119     {"AddUserDataText", (PyCFunction)UserDataObj_AddUserDataText, 1,
2120      PyDoc_STR("(Handle data, OSType udType, long index, short itlRegionTag) -> None")},
2121     {"GetUserDataText", (PyCFunction)UserDataObj_GetUserDataText, 1,
2122      PyDoc_STR("(Handle data, OSType udType, long index, short itlRegionTag) -> None")},
2123     {"RemoveUserDataText", (PyCFunction)UserDataObj_RemoveUserDataText, 1,
2124      PyDoc_STR("(OSType udType, long index, short itlRegionTag) -> None")},
2125     {"PutUserDataIntoHandle", (PyCFunction)UserDataObj_PutUserDataIntoHandle, 1,
2126      PyDoc_STR("(Handle h) -> None")},
2127     {"CopyUserData", (PyCFunction)UserDataObj_CopyUserData, 1,
2128      PyDoc_STR("(UserData dstUserData, OSType copyRule) -> None")},
2129     {NULL, NULL, 0}
2130 };
2131
2132 #define UserDataObj_getsetlist NULL
2133
2134
2135 #define UserDataObj_compare NULL
2136
2137 #define UserDataObj_repr NULL
2138
2139 #define UserDataObj_hash NULL
2140 #define UserDataObj_tp_init 0
2141
2142 #define UserDataObj_tp_alloc PyType_GenericAlloc
2143
2144 static PyObject *UserDataObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
2145 {
2146     PyObject *_self;
2147     UserData itself;
2148     char *kw[] = {"itself", 0};
2149
2150     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, UserDataObj_Convert, &itself)) return NULL;
2151     if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
2152     ((UserDataObject *)_self)->ob_itself = itself;
2153     return _self;
2154 }
2155
2156 #define UserDataObj_tp_free PyObject_Del
2157
2158
2159 PyTypeObject UserData_Type = {
2160     PyObject_HEAD_INIT(NULL)
2161     0, /*ob_size*/
2162     "_Qt.UserData", /*tp_name*/
2163     sizeof(UserDataObject), /*tp_basicsize*/
2164     0, /*tp_itemsize*/
2165     /* methods */
2166     (destructor) UserDataObj_dealloc, /*tp_dealloc*/
2167     0, /*tp_print*/
2168     (getattrfunc)0, /*tp_getattr*/
2169     (setattrfunc)0, /*tp_setattr*/
2170     (cmpfunc) UserDataObj_compare, /*tp_compare*/
2171     (reprfunc) UserDataObj_repr, /*tp_repr*/
2172     (PyNumberMethods *)0, /* tp_as_number */
2173     (PySequenceMethods *)0, /* tp_as_sequence */
2174     (PyMappingMethods *)0, /* tp_as_mapping */
2175     (hashfunc) UserDataObj_hash, /*tp_hash*/
2176     0, /*tp_call*/
2177     0, /*tp_str*/
2178     PyObject_GenericGetAttr, /*tp_getattro*/
2179     PyObject_GenericSetAttr, /*tp_setattro */
2180     0, /*tp_as_buffer*/
2181     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
2182     0, /*tp_doc*/
2183     0, /*tp_traverse*/
2184     0, /*tp_clear*/
2185     0, /*tp_richcompare*/
2186     0, /*tp_weaklistoffset*/
2187     0, /*tp_iter*/
2188     0, /*tp_iternext*/
2189     UserDataObj_methods, /* tp_methods */
2190     0, /*tp_members*/
2191     UserDataObj_getsetlist, /*tp_getset*/
2192     0, /*tp_base*/
2193     0, /*tp_dict*/
2194     0, /*tp_descr_get*/
2195     0, /*tp_descr_set*/
2196     0, /*tp_dictoffset*/
2197     UserDataObj_tp_init, /* tp_init */
2198     UserDataObj_tp_alloc, /* tp_alloc */
2199     UserDataObj_tp_new, /* tp_new */
2200     UserDataObj_tp_free, /* tp_free */
2201 };
2202
2203 /* -------------------- End object type UserData -------------------- */
2204
2205
2206 /* ----------------------- Object type Media ------------------------ */
2207
2208 PyTypeObject Media_Type;
2209
2210 #define MediaObj_Check(x) ((x)->ob_type == &Media_Type || PyObject_TypeCheck((x), &Media_Type))
2211
2212 typedef struct MediaObject {
2213     PyObject_HEAD
2214     Media ob_itself;
2215 } MediaObject;
2216
2217 PyObject *MediaObj_New(Media itself)
2218 {
2219     MediaObject *it;
2220     if (itself == NULL) {
2221                                     PyErr_SetString(Qt_Error,"Cannot create Media from NULL pointer");
2222                                     return NULL;
2223                             }
2224     it = PyObject_NEW(MediaObject, &Media_Type);
2225     if (it == NULL) return NULL;
2226     it->ob_itself = itself;
2227     return (PyObject *)it;
2228 }
2229
2230 int MediaObj_Convert(PyObject *v, Media *p_itself)
2231 {
2232     if (v == Py_None)
2233     {
2234         *p_itself = NULL;
2235         return 1;
2236     }
2237     if (!MediaObj_Check(v))
2238     {
2239         PyErr_SetString(PyExc_TypeError, "Media required");
2240         return 0;
2241     }
2242     *p_itself = ((MediaObject *)v)->ob_itself;
2243     return 1;
2244 }
2245
2246 static void MediaObj_dealloc(MediaObject *self)
2247 {
2248     if (self->ob_itself) DisposeTrackMedia(self->ob_itself);
2249     self->ob_type->tp_free((PyObject *)self);
2250 }
2251
2252 static PyObject *MediaObj_LoadMediaIntoRam(MediaObject *_self, PyObject *_args)
2253 {
2254     PyObject *_res = NULL;
2255     OSErr _err;
2256     TimeValue time;
2257     TimeValue duration;
2258     long flags;
2259 #ifndef LoadMediaIntoRam
2260     PyMac_PRECHECK(LoadMediaIntoRam);
2261 #endif
2262     if (!PyArg_ParseTuple(_args, "lll",
2263                           &time,
2264                           &duration,
2265                           &flags))
2266         return NULL;
2267     _err = LoadMediaIntoRam(_self->ob_itself,
2268                             time,
2269                             duration,
2270                             flags);
2271     if (_err != noErr) return PyMac_Error(_err);
2272     Py_INCREF(Py_None);
2273     _res = Py_None;
2274     return _res;
2275 }
2276
2277 static PyObject *MediaObj_GetMediaTrack(MediaObject *_self, PyObject *_args)
2278 {
2279     PyObject *_res = NULL;
2280     Track _rv;
2281 #ifndef GetMediaTrack
2282     PyMac_PRECHECK(GetMediaTrack);
2283 #endif
2284     if (!PyArg_ParseTuple(_args, ""))
2285         return NULL;
2286     _rv = GetMediaTrack(_self->ob_itself);
2287     _res = Py_BuildValue("O&",
2288                          TrackObj_New, _rv);
2289     return _res;
2290 }
2291
2292 static PyObject *MediaObj_GetMediaCreationTime(MediaObject *_self, PyObject *_args)
2293 {
2294     PyObject *_res = NULL;
2295     unsigned long _rv;
2296 #ifndef GetMediaCreationTime
2297     PyMac_PRECHECK(GetMediaCreationTime);
2298 #endif
2299     if (!PyArg_ParseTuple(_args, ""))
2300         return NULL;
2301     _rv = GetMediaCreationTime(_self->ob_itself);
2302     _res = Py_BuildValue("l",
2303                          _rv);
2304     return _res;
2305 }
2306
2307 static PyObject *MediaObj_GetMediaModificationTime(MediaObject *_self, PyObject *_args)
2308 {
2309     PyObject *_res = NULL;
2310     unsigned long _rv;
2311 #ifndef GetMediaModificationTime
2312     PyMac_PRECHECK(GetMediaModificationTime);
2313 #endif
2314     if (!PyArg_ParseTuple(_args, ""))
2315         return NULL;
2316     _rv = GetMediaModificationTime(_self->ob_itself);
2317     _res = Py_BuildValue("l",
2318                          _rv);
2319     return _res;
2320 }
2321
2322 static PyObject *MediaObj_GetMediaTimeScale(MediaObject *_self, PyObject *_args)
2323 {
2324     PyObject *_res = NULL;
2325     TimeScale _rv;
2326 #ifndef GetMediaTimeScale
2327     PyMac_PRECHECK(GetMediaTimeScale);
2328 #endif
2329     if (!PyArg_ParseTuple(_args, ""))
2330         return NULL;
2331     _rv = GetMediaTimeScale(_self->ob_itself);
2332     _res = Py_BuildValue("l",
2333                          _rv);
2334     return _res;
2335 }
2336
2337 static PyObject *MediaObj_SetMediaTimeScale(MediaObject *_self, PyObject *_args)
2338 {
2339     PyObject *_res = NULL;
2340     TimeScale timeScale;
2341 #ifndef SetMediaTimeScale
2342     PyMac_PRECHECK(SetMediaTimeScale);
2343 #endif
2344     if (!PyArg_ParseTuple(_args, "l",
2345                           &timeScale))
2346         return NULL;
2347     SetMediaTimeScale(_self->ob_itself,
2348                       timeScale);
2349     Py_INCREF(Py_None);
2350     _res = Py_None;
2351     return _res;
2352 }
2353
2354 static PyObject *MediaObj_GetMediaDuration(MediaObject *_self, PyObject *_args)
2355 {
2356     PyObject *_res = NULL;
2357     TimeValue _rv;
2358 #ifndef GetMediaDuration
2359     PyMac_PRECHECK(GetMediaDuration);
2360 #endif
2361     if (!PyArg_ParseTuple(_args, ""))
2362         return NULL;
2363     _rv = GetMediaDuration(_self->ob_itself);
2364     _res = Py_BuildValue("l",
2365                          _rv);
2366     return _res;
2367 }
2368
2369 static PyObject *MediaObj_GetMediaLanguage(MediaObject *_self, PyObject *_args)
2370 {
2371     PyObject *_res = NULL;
2372     short _rv;
2373 #ifndef GetMediaLanguage
2374     PyMac_PRECHECK(GetMediaLanguage);
2375 #endif
2376     if (!PyArg_ParseTuple(_args, ""))
2377         return NULL;
2378     _rv = GetMediaLanguage(_self->ob_itself);
2379     _res = Py_BuildValue("h",
2380                          _rv);
2381     return _res;
2382 }
2383
2384 static PyObject *MediaObj_SetMediaLanguage(MediaObject *_self, PyObject *_args)
2385 {
2386     PyObject *_res = NULL;
2387     short language;
2388 #ifndef SetMediaLanguage
2389     PyMac_PRECHECK(SetMediaLanguage);
2390 #endif
2391     if (!PyArg_ParseTuple(_args, "h",
2392                           &language))
2393         return NULL;
2394     SetMediaLanguage(_self->ob_itself,
2395                      language);
2396     Py_INCREF(Py_None);
2397     _res = Py_None;
2398     return _res;
2399 }
2400
2401 static PyObject *MediaObj_GetMediaQuality(MediaObject *_self, PyObject *_args)
2402 {
2403     PyObject *_res = NULL;
2404     short _rv;
2405 #ifndef GetMediaQuality
2406     PyMac_PRECHECK(GetMediaQuality);
2407 #endif
2408     if (!PyArg_ParseTuple(_args, ""))
2409         return NULL;
2410     _rv = GetMediaQuality(_self->ob_itself);
2411     _res = Py_BuildValue("h",
2412                          _rv);
2413     return _res;
2414 }
2415
2416 static PyObject *MediaObj_SetMediaQuality(MediaObject *_self, PyObject *_args)
2417 {
2418     PyObject *_res = NULL;
2419     short quality;
2420 #ifndef SetMediaQuality
2421     PyMac_PRECHECK(SetMediaQuality);
2422 #endif
2423     if (!PyArg_ParseTuple(_args, "h",
2424                           &quality))
2425         return NULL;
2426     SetMediaQuality(_self->ob_itself,
2427                     quality);
2428     Py_INCREF(Py_None);
2429     _res = Py_None;
2430     return _res;
2431 }
2432
2433 static PyObject *MediaObj_GetMediaHandlerDescription(MediaObject *_self, PyObject *_args)
2434 {
2435     PyObject *_res = NULL;
2436     OSType mediaType;
2437     Str255 creatorName;
2438     OSType creatorManufacturer;
2439 #ifndef GetMediaHandlerDescription
2440     PyMac_PRECHECK(GetMediaHandlerDescription);
2441 #endif
2442     if (!PyArg_ParseTuple(_args, "O&",
2443                           PyMac_GetStr255, creatorName))
2444         return NULL;
2445     GetMediaHandlerDescription(_self->ob_itself,
2446                                &mediaType,
2447                                creatorName,
2448                                &creatorManufacturer);
2449     _res = Py_BuildValue("O&O&",
2450                          PyMac_BuildOSType, mediaType,
2451                          PyMac_BuildOSType, creatorManufacturer);
2452     return _res;
2453 }
2454
2455 static PyObject *MediaObj_GetMediaUserData(MediaObject *_self, PyObject *_args)
2456 {
2457     PyObject *_res = NULL;
2458     UserData _rv;
2459 #ifndef GetMediaUserData
2460     PyMac_PRECHECK(GetMediaUserData);
2461 #endif
2462     if (!PyArg_ParseTuple(_args, ""))
2463         return NULL;
2464     _rv = GetMediaUserData(_self->ob_itself);
2465     _res = Py_BuildValue("O&",
2466                          UserDataObj_New, _rv);
2467     return _res;
2468 }
2469
2470 static PyObject *MediaObj_GetMediaHandler(MediaObject *_self, PyObject *_args)
2471 {
2472     PyObject *_res = NULL;
2473     MediaHandler _rv;
2474 #ifndef GetMediaHandler
2475     PyMac_PRECHECK(GetMediaHandler);
2476 #endif
2477     if (!PyArg_ParseTuple(_args, ""))
2478         return NULL;
2479     _rv = GetMediaHandler(_self->ob_itself);
2480     _res = Py_BuildValue("O&",
2481                          CmpInstObj_New, _rv);
2482     return _res;
2483 }
2484
2485 static PyObject *MediaObj_SetMediaHandler(MediaObject *_self, PyObject *_args)
2486 {
2487     PyObject *_res = NULL;
2488     OSErr _err;
2489     MediaHandlerComponent mH;
2490 #ifndef SetMediaHandler
2491     PyMac_PRECHECK(SetMediaHandler);
2492 #endif
2493     if (!PyArg_ParseTuple(_args, "O&",
2494                           CmpObj_Convert, &mH))
2495         return NULL;
2496     _err = SetMediaHandler(_self->ob_itself,
2497                            mH);
2498     if (_err != noErr) return PyMac_Error(_err);
2499     Py_INCREF(Py_None);
2500     _res = Py_None;
2501     return _res;
2502 }
2503
2504 static PyObject *MediaObj_BeginMediaEdits(MediaObject *_self, PyObject *_args)
2505 {
2506     PyObject *_res = NULL;
2507     OSErr _err;
2508 #ifndef BeginMediaEdits
2509     PyMac_PRECHECK(BeginMediaEdits);
2510 #endif
2511     if (!PyArg_ParseTuple(_args, ""))
2512         return NULL;
2513     _err = BeginMediaEdits(_self->ob_itself);
2514     if (_err != noErr) return PyMac_Error(_err);
2515     Py_INCREF(Py_None);
2516     _res = Py_None;
2517     return _res;
2518 }
2519
2520 static PyObject *MediaObj_EndMediaEdits(MediaObject *_self, PyObject *_args)
2521 {
2522     PyObject *_res = NULL;
2523     OSErr _err;
2524 #ifndef EndMediaEdits
2525     PyMac_PRECHECK(EndMediaEdits);
2526 #endif
2527     if (!PyArg_ParseTuple(_args, ""))
2528         return NULL;
2529     _err = EndMediaEdits(_self->ob_itself);
2530     if (_err != noErr) return PyMac_Error(_err);
2531     Py_INCREF(Py_None);
2532     _res = Py_None;
2533     return _res;
2534 }
2535
2536 static PyObject *MediaObj_SetMediaDefaultDataRefIndex(MediaObject *_self, PyObject *_args)
2537 {
2538     PyObject *_res = NULL;
2539     OSErr _err;
2540     short index;
2541 #ifndef SetMediaDefaultDataRefIndex
2542     PyMac_PRECHECK(SetMediaDefaultDataRefIndex);
2543 #endif
2544     if (!PyArg_ParseTuple(_args, "h",
2545                           &index))
2546         return NULL;
2547     _err = SetMediaDefaultDataRefIndex(_self->ob_itself,
2548                                        index);
2549     if (_err != noErr) return PyMac_Error(_err);
2550     Py_INCREF(Py_None);
2551     _res = Py_None;
2552     return _res;
2553 }
2554
2555 static PyObject *MediaObj_GetMediaDataHandlerDescription(MediaObject *_self, PyObject *_args)
2556 {
2557     PyObject *_res = NULL;
2558     short index;
2559     OSType dhType;
2560     Str255 creatorName;
2561     OSType creatorManufacturer;
2562 #ifndef GetMediaDataHandlerDescription
2563     PyMac_PRECHECK(GetMediaDataHandlerDescription);
2564 #endif
2565     if (!PyArg_ParseTuple(_args, "hO&",
2566                           &index,
2567                           PyMac_GetStr255, creatorName))
2568         return NULL;
2569     GetMediaDataHandlerDescription(_self->ob_itself,
2570                                    index,
2571                                    &dhType,
2572                                    creatorName,
2573                                    &creatorManufacturer);
2574     _res = Py_BuildValue("O&O&",
2575                          PyMac_BuildOSType, dhType,
2576                          PyMac_BuildOSType, creatorManufacturer);
2577     return _res;
2578 }
2579
2580 static PyObject *MediaObj_GetMediaDataHandler(MediaObject *_self, PyObject *_args)
2581 {
2582     PyObject *_res = NULL;
2583     DataHandler _rv;
2584     short index;
2585 #ifndef GetMediaDataHandler
2586     PyMac_PRECHECK(GetMediaDataHandler);
2587 #endif
2588     if (!PyArg_ParseTuple(_args, "h",
2589                           &index))
2590         return NULL;
2591     _rv = GetMediaDataHandler(_self->ob_itself,
2592                               index);
2593     _res = Py_BuildValue("O&",
2594                          CmpInstObj_New, _rv);
2595     return _res;
2596 }
2597
2598 static PyObject *MediaObj_SetMediaDataHandler(MediaObject *_self, PyObject *_args)
2599 {
2600     PyObject *_res = NULL;
2601     OSErr _err;
2602     short index;
2603     DataHandlerComponent dataHandler;
2604 #ifndef SetMediaDataHandler
2605     PyMac_PRECHECK(SetMediaDataHandler);
2606 #endif
2607     if (!PyArg_ParseTuple(_args, "hO&",
2608                           &index,
2609                           CmpObj_Convert, &dataHandler))
2610         return NULL;
2611     _err = SetMediaDataHandler(_self->ob_itself,
2612                                index,
2613                                dataHandler);
2614     if (_err != noErr) return PyMac_Error(_err);
2615     Py_INCREF(Py_None);
2616     _res = Py_None;
2617     return _res;
2618 }
2619
2620 static PyObject *MediaObj_GetMediaSampleDescriptionCount(MediaObject *_self, PyObject *_args)
2621 {
2622     PyObject *_res = NULL;
2623     long _rv;
2624 #ifndef GetMediaSampleDescriptionCount
2625     PyMac_PRECHECK(GetMediaSampleDescriptionCount);
2626 #endif
2627     if (!PyArg_ParseTuple(_args, ""))
2628         return NULL;
2629     _rv = GetMediaSampleDescriptionCount(_self->ob_itself);
2630     _res = Py_BuildValue("l",
2631                          _rv);
2632     return _res;
2633 }
2634
2635 static PyObject *MediaObj_GetMediaSampleDescription(MediaObject *_self, PyObject *_args)
2636 {
2637     PyObject *_res = NULL;
2638     long index;
2639     SampleDescriptionHandle descH;
2640 #ifndef GetMediaSampleDescription
2641     PyMac_PRECHECK(GetMediaSampleDescription);
2642 #endif
2643     if (!PyArg_ParseTuple(_args, "lO&",
2644                           &index,
2645                           ResObj_Convert, &descH))
2646         return NULL;
2647     GetMediaSampleDescription(_self->ob_itself,
2648                               index,
2649                               descH);
2650     Py_INCREF(Py_None);
2651     _res = Py_None;
2652     return _res;
2653 }
2654
2655 static PyObject *MediaObj_SetMediaSampleDescription(MediaObject *_self, PyObject *_args)
2656 {
2657     PyObject *_res = NULL;
2658     OSErr _err;
2659     long index;
2660     SampleDescriptionHandle descH;
2661 #ifndef SetMediaSampleDescription
2662     PyMac_PRECHECK(SetMediaSampleDescription);
2663 #endif
2664     if (!PyArg_ParseTuple(_args, "lO&",
2665                           &index,
2666                           ResObj_Convert, &descH))
2667         return NULL;
2668     _err = SetMediaSampleDescription(_self->ob_itself,
2669                                      index,
2670                                      descH);
2671     if (_err != noErr) return PyMac_Error(_err);
2672     Py_INCREF(Py_None);
2673     _res = Py_None;
2674     return _res;
2675 }
2676
2677 static PyObject *MediaObj_GetMediaSampleCount(MediaObject *_self, PyObject *_args)
2678 {
2679     PyObject *_res = NULL;
2680     long _rv;
2681 #ifndef GetMediaSampleCount
2682     PyMac_PRECHECK(GetMediaSampleCount);
2683 #endif
2684     if (!PyArg_ParseTuple(_args, ""))
2685         return NULL;
2686     _rv = GetMediaSampleCount(_self->ob_itself);
2687     _res = Py_BuildValue("l",
2688                          _rv);
2689     return _res;
2690 }
2691
2692 static PyObject *MediaObj_GetMediaSyncSampleCount(MediaObject *_self, PyObject *_args)
2693 {
2694     PyObject *_res = NULL;
2695     long _rv;
2696 #ifndef GetMediaSyncSampleCount
2697     PyMac_PRECHECK(GetMediaSyncSampleCount);
2698 #endif
2699     if (!PyArg_ParseTuple(_args, ""))
2700         return NULL;
2701     _rv = GetMediaSyncSampleCount(_self->ob_itself);
2702     _res = Py_BuildValue("l",
2703                          _rv);
2704     return _res;
2705 }
2706
2707 static PyObject *MediaObj_SampleNumToMediaTime(MediaObject *_self, PyObject *_args)
2708 {
2709     PyObject *_res = NULL;
2710     long logicalSampleNum;
2711     TimeValue sampleTime;
2712     TimeValue sampleDuration;
2713 #ifndef SampleNumToMediaTime
2714     PyMac_PRECHECK(SampleNumToMediaTime);
2715 #endif
2716     if (!PyArg_ParseTuple(_args, "l",
2717                           &logicalSampleNum))
2718         return NULL;
2719     SampleNumToMediaTime(_self->ob_itself,
2720                          logicalSampleNum,
2721                          &sampleTime,
2722                          &sampleDuration);
2723     _res = Py_BuildValue("ll",
2724                          sampleTime,
2725                          sampleDuration);
2726     return _res;
2727 }
2728
2729 static PyObject *MediaObj_MediaTimeToSampleNum(MediaObject *_self, PyObject *_args)
2730 {
2731     PyObject *_res = NULL;
2732     TimeValue time;
2733     long sampleNum;
2734     TimeValue sampleTime;
2735     TimeValue sampleDuration;
2736 #ifndef MediaTimeToSampleNum
2737     PyMac_PRECHECK(MediaTimeToSampleNum);
2738 #endif
2739     if (!PyArg_ParseTuple(_args, "l",
2740                           &time))
2741         return NULL;
2742     MediaTimeToSampleNum(_self->ob_itself,
2743                          time,
2744                          &sampleNum,
2745                          &sampleTime,
2746                          &sampleDuration);
2747     _res = Py_BuildValue("lll",
2748                          sampleNum,
2749                          sampleTime,
2750                          sampleDuration);
2751     return _res;
2752 }
2753
2754 static PyObject *MediaObj_AddMediaSample(MediaObject *_self, PyObject *_args)
2755 {
2756     PyObject *_res = NULL;
2757     OSErr _err;
2758     Handle dataIn;
2759     long inOffset;
2760     unsigned long size;
2761     TimeValue durationPerSample;
2762     SampleDescriptionHandle sampleDescriptionH;
2763     long numberOfSamples;
2764     short sampleFlags;
2765     TimeValue sampleTime;
2766 #ifndef AddMediaSample
2767     PyMac_PRECHECK(AddMediaSample);
2768 #endif
2769     if (!PyArg_ParseTuple(_args, "O&lllO&lh",
2770                           ResObj_Convert, &dataIn,
2771                           &inOffset,
2772                           &size,
2773                           &durationPerSample,
2774                           ResObj_Convert, &sampleDescriptionH,
2775                           &numberOfSamples,
2776                           &sampleFlags))
2777         return NULL;
2778     _err = AddMediaSample(_self->ob_itself,
2779                           dataIn,
2780                           inOffset,
2781                           size,
2782                           durationPerSample,
2783                           sampleDescriptionH,
2784                           numberOfSamples,
2785                           sampleFlags,
2786                           &sampleTime);
2787     if (_err != noErr) return PyMac_Error(_err);
2788     _res = Py_BuildValue("l",
2789                          sampleTime);
2790     return _res;
2791 }
2792
2793 static PyObject *MediaObj_AddMediaSampleReference(MediaObject *_self, PyObject *_args)
2794 {
2795     PyObject *_res = NULL;
2796     OSErr _err;
2797     long dataOffset;
2798     unsigned long size;
2799     TimeValue durationPerSample;
2800     SampleDescriptionHandle sampleDescriptionH;
2801     long numberOfSamples;
2802     short sampleFlags;
2803     TimeValue sampleTime;
2804 #ifndef AddMediaSampleReference
2805     PyMac_PRECHECK(AddMediaSampleReference);
2806 #endif
2807     if (!PyArg_ParseTuple(_args, "lllO&lh",
2808                           &dataOffset,
2809                           &size,
2810                           &durationPerSample,
2811                           ResObj_Convert, &sampleDescriptionH,
2812                           &numberOfSamples,
2813                           &sampleFlags))
2814         return NULL;
2815     _err = AddMediaSampleReference(_self->ob_itself,
2816                                    dataOffset,
2817                                    size,
2818                                    durationPerSample,
2819                                    sampleDescriptionH,
2820                                    numberOfSamples,
2821                                    sampleFlags,
2822                                    &sampleTime);
2823     if (_err != noErr) return PyMac_Error(_err);
2824     _res = Py_BuildValue("l",
2825                          sampleTime);
2826     return _res;
2827 }
2828
2829 static PyObject *MediaObj_GetMediaSample(MediaObject *_self, PyObject *_args)
2830 {
2831     PyObject *_res = NULL;
2832     OSErr _err;
2833     Handle dataOut;
2834     long maxSizeToGrow;
2835     long size;
2836     TimeValue time;
2837     TimeValue sampleTime;
2838     TimeValue durationPerSample;
2839     SampleDescriptionHandle sampleDescriptionH;
2840     long sampleDescriptionIndex;
2841     long maxNumberOfSamples;
2842     long numberOfSamples;
2843     short sampleFlags;
2844 #ifndef GetMediaSample
2845     PyMac_PRECHECK(GetMediaSample);
2846 #endif
2847     if (!PyArg_ParseTuple(_args, "O&llO&l",
2848                           ResObj_Convert, &dataOut,
2849                           &maxSizeToGrow,
2850                           &time,
2851                           ResObj_Convert, &sampleDescriptionH,
2852                           &maxNumberOfSamples))
2853         return NULL;
2854     _err = GetMediaSample(_self->ob_itself,
2855                           dataOut,
2856                           maxSizeToGrow,
2857                           &size,
2858                           time,
2859                           &sampleTime,
2860                           &durationPerSample,
2861                           sampleDescriptionH,
2862                           &sampleDescriptionIndex,
2863                           maxNumberOfSamples,
2864                           &numberOfSamples,
2865                           &sampleFlags);
2866     if (_err != noErr) return PyMac_Error(_err);
2867     _res = Py_BuildValue("lllllh",
2868                          size,
2869                          sampleTime,
2870                          durationPerSample,
2871                          sampleDescriptionIndex,
2872                          numberOfSamples,
2873                          sampleFlags);
2874     return _res;
2875 }
2876
2877 static PyObject *MediaObj_GetMediaSampleReference(MediaObject *_self, PyObject *_args)
2878 {
2879     PyObject *_res = NULL;
2880     OSErr _err;
2881     long dataOffset;
2882     long size;
2883     TimeValue time;
2884     TimeValue sampleTime;
2885     TimeValue durationPerSample;
2886     SampleDescriptionHandle sampleDescriptionH;
2887     long sampleDescriptionIndex;
2888     long maxNumberOfSamples;
2889     long numberOfSamples;
2890     short sampleFlags;
2891 #ifndef GetMediaSampleReference
2892     PyMac_PRECHECK(GetMediaSampleReference);
2893 #endif
2894     if (!PyArg_ParseTuple(_args, "lO&l",
2895                           &time,
2896                           ResObj_Convert, &sampleDescriptionH,
2897                           &maxNumberOfSamples))
2898         return NULL;
2899     _err = GetMediaSampleReference(_self->ob_itself,
2900                                    &dataOffset,
2901                                    &size,
2902                                    time,
2903                                    &sampleTime,
2904                                    &durationPerSample,
2905                                    sampleDescriptionH,
2906                                    &sampleDescriptionIndex,
2907                                    maxNumberOfSamples,
2908                                    &numberOfSamples,
2909                                    &sampleFlags);
2910     if (_err != noErr) return PyMac_Error(_err);
2911     _res = Py_BuildValue("llllllh",
2912                          dataOffset,
2913                          size,
2914                          sampleTime,
2915                          durationPerSample,
2916                          sampleDescriptionIndex,
2917                          numberOfSamples,
2918                          sampleFlags);
2919     return _res;
2920 }
2921
2922 static PyObject *MediaObj_SetMediaPreferredChunkSize(MediaObject *_self, PyObject *_args)
2923 {
2924     PyObject *_res = NULL;
2925     OSErr _err;
2926     long maxChunkSize;
2927 #ifndef SetMediaPreferredChunkSize
2928     PyMac_PRECHECK(SetMediaPreferredChunkSize);
2929 #endif
2930     if (!PyArg_ParseTuple(_args, "l",
2931                           &maxChunkSize))
2932         return NULL;
2933     _err = SetMediaPreferredChunkSize(_self->ob_itself,
2934                                       maxChunkSize);
2935     if (_err != noErr) return PyMac_Error(_err);
2936     Py_INCREF(Py_None);
2937     _res = Py_None;
2938     return _res;
2939 }
2940
2941 static PyObject *MediaObj_GetMediaPreferredChunkSize(MediaObject *_self, PyObject *_args)
2942 {
2943     PyObject *_res = NULL;
2944     OSErr _err;
2945     long maxChunkSize;
2946 #ifndef GetMediaPreferredChunkSize
2947     PyMac_PRECHECK(GetMediaPreferredChunkSize);
2948 #endif
2949     if (!PyArg_ParseTuple(_args, ""))
2950         return NULL;
2951     _err = GetMediaPreferredChunkSize(_self->ob_itself,
2952                                       &maxChunkSize);
2953     if (_err != noErr) return PyMac_Error(_err);
2954     _res = Py_BuildValue("l",
2955                          maxChunkSize);
2956     return _res;
2957 }
2958
2959 static PyObject *MediaObj_SetMediaShadowSync(MediaObject *_self, PyObject *_args)
2960 {
2961     PyObject *_res = NULL;
2962     OSErr _err;
2963     long frameDiffSampleNum;
2964     long syncSampleNum;
2965 #ifndef SetMediaShadowSync
2966     PyMac_PRECHECK(SetMediaShadowSync);
2967 #endif
2968     if (!PyArg_ParseTuple(_args, "ll",
2969                           &frameDiffSampleNum,
2970                           &syncSampleNum))
2971         return NULL;
2972     _err = SetMediaShadowSync(_self->ob_itself,
2973                               frameDiffSampleNum,
2974                               syncSampleNum);
2975     if (_err != noErr) return PyMac_Error(_err);
2976     Py_INCREF(Py_None);
2977     _res = Py_None;
2978     return _res;
2979 }
2980
2981 static PyObject *MediaObj_GetMediaShadowSync(MediaObject *_self, PyObject *_args)
2982 {
2983     PyObject *_res = NULL;
2984     OSErr _err;
2985     long frameDiffSampleNum;
2986     long syncSampleNum;
2987 #ifndef GetMediaShadowSync
2988     PyMac_PRECHECK(GetMediaShadowSync);
2989 #endif
2990     if (!PyArg_ParseTuple(_args, "l",
2991                           &frameDiffSampleNum))
2992         return NULL;
2993     _err = GetMediaShadowSync(_self->ob_itself,
2994                               frameDiffSampleNum,
2995                               &syncSampleNum);
2996     if (_err != noErr) return PyMac_Error(_err);
2997     _res = Py_BuildValue("l",
2998                          syncSampleNum);
2999     return _res;
3000 }
3001
3002 static PyObject *MediaObj_GetMediaDataSize(MediaObject *_self, PyObject *_args)
3003 {
3004     PyObject *_res = NULL;
3005     long _rv;
3006     TimeValue startTime;
3007     TimeValue duration;
3008 #ifndef GetMediaDataSize
3009     PyMac_PRECHECK(GetMediaDataSize);
3010 #endif
3011     if (!PyArg_ParseTuple(_args, "ll",
3012                           &startTime,
3013                           &duration))
3014         return NULL;
3015     _rv = GetMediaDataSize(_self->ob_itself,
3016                            startTime,
3017                            duration);
3018     _res = Py_BuildValue("l",
3019                          _rv);
3020     return _res;
3021 }
3022
3023 static PyObject *MediaObj_GetMediaDataSize64(MediaObject *_self, PyObject *_args)
3024 {
3025     PyObject *_res = NULL;
3026     OSErr _err;
3027     TimeValue startTime;
3028     TimeValue duration;
3029     wide dataSize;
3030 #ifndef GetMediaDataSize64
3031     PyMac_PRECHECK(GetMediaDataSize64);
3032 #endif
3033     if (!PyArg_ParseTuple(_args, "ll",
3034                           &startTime,
3035                           &duration))
3036         return NULL;
3037     _err = GetMediaDataSize64(_self->ob_itself,
3038                               startTime,
3039                               duration,
3040                               &dataSize);
3041     if (_err != noErr) return PyMac_Error(_err);
3042     _res = Py_BuildValue("O&",
3043                          PyMac_Buildwide, dataSize);
3044     return _res;
3045 }
3046
3047 static PyObject *MediaObj_CopyMediaUserData(MediaObject *_self, PyObject *_args)
3048 {
3049     PyObject *_res = NULL;
3050     OSErr _err;
3051     Media dstMedia;
3052     OSType copyRule;
3053 #ifndef CopyMediaUserData
3054     PyMac_PRECHECK(CopyMediaUserData);
3055 #endif
3056     if (!PyArg_ParseTuple(_args, "O&O&",
3057                           MediaObj_Convert, &dstMedia,
3058                           PyMac_GetOSType, &copyRule))
3059         return NULL;
3060     _err = CopyMediaUserData(_self->ob_itself,
3061                              dstMedia,
3062                              copyRule);
3063     if (_err != noErr) return PyMac_Error(_err);
3064     Py_INCREF(Py_None);
3065     _res = Py_None;
3066     return _res;
3067 }
3068
3069 static PyObject *MediaObj_GetMediaNextInterestingTime(MediaObject *_self, PyObject *_args)
3070 {
3071     PyObject *_res = NULL;
3072     short interestingTimeFlags;
3073     TimeValue time;
3074     Fixed rate;
3075     TimeValue interestingTime;
3076     TimeValue interestingDuration;
3077 #ifndef GetMediaNextInterestingTime
3078     PyMac_PRECHECK(GetMediaNextInterestingTime);
3079 #endif
3080     if (!PyArg_ParseTuple(_args, "hlO&",
3081                           &interestingTimeFlags,
3082                           &time,
3083                           PyMac_GetFixed, &rate))
3084         return NULL;
3085     GetMediaNextInterestingTime(_self->ob_itself,
3086                                 interestingTimeFlags,
3087                                 time,
3088                                 rate,
3089                                 &interestingTime,
3090                                 &interestingDuration);
3091     _res = Py_BuildValue("ll",
3092                          interestingTime,
3093                          interestingDuration);
3094     return _res;
3095 }
3096
3097 static PyObject *MediaObj_GetMediaDataRef(MediaObject *_self, PyObject *_args)
3098 {
3099     PyObject *_res = NULL;
3100     OSErr _err;
3101     short index;
3102     Handle dataRef;
3103     OSType dataRefType;
3104     long dataRefAttributes;
3105 #ifndef GetMediaDataRef
3106     PyMac_PRECHECK(GetMediaDataRef);
3107 #endif
3108     if (!PyArg_ParseTuple(_args, "h",
3109                           &index))
3110         return NULL;
3111     _err = GetMediaDataRef(_self->ob_itself,
3112                            index,
3113                            &dataRef,
3114                            &dataRefType,
3115                            &dataRefAttributes);
3116     if (_err != noErr) return PyMac_Error(_err);
3117     _res = Py_BuildValue("O&O&l",
3118                          ResObj_New, dataRef,
3119                          PyMac_BuildOSType, dataRefType,
3120                          dataRefAttributes);
3121     return _res;
3122 }
3123
3124 static PyObject *MediaObj_SetMediaDataRef(MediaObject *_self, PyObject *_args)
3125 {
3126     PyObject *_res = NULL;
3127     OSErr _err;
3128     short index;
3129     Handle dataRef;
3130     OSType dataRefType;
3131 #ifndef SetMediaDataRef
3132     PyMac_PRECHECK(SetMediaDataRef);
3133 #endif
3134     if (!PyArg_ParseTuple(_args, "hO&O&",
3135                           &index,
3136                           ResObj_Convert, &dataRef,
3137                           PyMac_GetOSType, &dataRefType))
3138         return NULL;
3139     _err = SetMediaDataRef(_self->ob_itself,
3140                            index,
3141                            dataRef,
3142                            dataRefType);
3143     if (_err != noErr) return PyMac_Error(_err);
3144     Py_INCREF(Py_None);
3145     _res = Py_None;
3146     return _res;
3147 }
3148
3149 static PyObject *MediaObj_SetMediaDataRefAttributes(MediaObject *_self, PyObject *_args)
3150 {
3151     PyObject *_res = NULL;
3152     OSErr _err;
3153     short index;
3154     long dataRefAttributes;
3155 #ifndef SetMediaDataRefAttributes
3156     PyMac_PRECHECK(SetMediaDataRefAttributes);
3157 #endif
3158     if (!PyArg_ParseTuple(_args, "hl",
3159                           &index,
3160                           &dataRefAttributes))
3161         return NULL;
3162     _err = SetMediaDataRefAttributes(_self->ob_itself,
3163                                      index,
3164                                      dataRefAttributes);
3165     if (_err != noErr) return PyMac_Error(_err);
3166     Py_INCREF(Py_None);
3167     _res = Py_None;
3168     return _res;
3169 }
3170
3171 static PyObject *MediaObj_AddMediaDataRef(MediaObject *_self, PyObject *_args)
3172 {
3173     PyObject *_res = NULL;
3174     OSErr _err;
3175     short index;
3176     Handle dataRef;
3177     OSType dataRefType;
3178 #ifndef AddMediaDataRef
3179     PyMac_PRECHECK(AddMediaDataRef);
3180 #endif
3181     if (!PyArg_ParseTuple(_args, "O&O&",
3182                           ResObj_Convert, &dataRef,
3183                           PyMac_GetOSType, &dataRefType))
3184         return NULL;
3185     _err = AddMediaDataRef(_self->ob_itself,
3186                            &index,
3187                            dataRef,
3188                            dataRefType);
3189     if (_err != noErr) return PyMac_Error(_err);
3190     _res = Py_BuildValue("h",
3191                          index);
3192     return _res;
3193 }
3194
3195 static PyObject *MediaObj_GetMediaDataRefCount(MediaObject *_self, PyObject *_args)
3196 {
3197     PyObject *_res = NULL;
3198     OSErr _err;
3199     short count;
3200 #ifndef GetMediaDataRefCount
3201     PyMac_PRECHECK(GetMediaDataRefCount);
3202 #endif
3203     if (!PyArg_ParseTuple(_args, ""))
3204         return NULL;
3205     _err = GetMediaDataRefCount(_self->ob_itself,
3206                                 &count);
3207     if (_err != noErr) return PyMac_Error(_err);
3208     _res = Py_BuildValue("h",
3209                          count);
3210     return _res;
3211 }
3212
3213 static PyObject *MediaObj_SetMediaPlayHints(MediaObject *_self, PyObject *_args)
3214 {
3215     PyObject *_res = NULL;
3216     long flags;
3217     long flagsMask;
3218 #ifndef SetMediaPlayHints
3219     PyMac_PRECHECK(SetMediaPlayHints);
3220 #endif
3221     if (!PyArg_ParseTuple(_args, "ll",
3222                           &flags,
3223                           &flagsMask))
3224         return NULL;
3225     SetMediaPlayHints(_self->ob_itself,
3226                       flags,
3227                       flagsMask);
3228     Py_INCREF(Py_None);
3229     _res = Py_None;
3230     return _res;
3231 }
3232
3233 static PyObject *MediaObj_GetMediaPlayHints(MediaObject *_self, PyObject *_args)
3234 {
3235     PyObject *_res = NULL;
3236     long flags;
3237 #ifndef GetMediaPlayHints
3238     PyMac_PRECHECK(GetMediaPlayHints);
3239 #endif
3240     if (!PyArg_ParseTuple(_args, ""))
3241         return NULL;
3242     GetMediaPlayHints(_self->ob_itself,
3243                       &flags);
3244     _res = Py_BuildValue("l",
3245                          flags);
3246     return _res;
3247 }
3248
3249 static PyObject *MediaObj_GetMediaNextInterestingTimeOnly(MediaObject *_self, PyObject *_args)
3250 {
3251     PyObject *_res = NULL;
3252     short interestingTimeFlags;
3253     TimeValue time;
3254     Fixed rate;
3255     TimeValue interestingTime;
3256 #ifndef GetMediaNextInterestingTimeOnly
3257     PyMac_PRECHECK(GetMediaNextInterestingTimeOnly);
3258 #endif
3259     if (!PyArg_ParseTuple(_args, "hlO&",
3260                           &interestingTimeFlags,
3261                           &time,
3262                           PyMac_GetFixed, &rate))
3263         return NULL;
3264     GetMediaNextInterestingTimeOnly(_self->ob_itself,
3265                                     interestingTimeFlags,
3266                                     time,
3267                                     rate,
3268                                     &interestingTime);
3269     _res = Py_BuildValue("l",
3270                          interestingTime);
3271     return _res;
3272 }
3273
3274 static PyMethodDef MediaObj_methods[] = {
3275     {"LoadMediaIntoRam", (PyCFunction)MediaObj_LoadMediaIntoRam, 1,
3276      PyDoc_STR("(TimeValue time, TimeValue duration, long flags) -> None")},
3277     {"GetMediaTrack", (PyCFunction)MediaObj_GetMediaTrack, 1,
3278      PyDoc_STR("() -> (Track _rv)")},
3279     {"GetMediaCreationTime", (PyCFunction)MediaObj_GetMediaCreationTime, 1,
3280      PyDoc_STR("() -> (unsigned long _rv)")},
3281     {"GetMediaModificationTime", (PyCFunction)MediaObj_GetMediaModificationTime, 1,
3282      PyDoc_STR("() -> (unsigned long _rv)")},
3283     {"GetMediaTimeScale", (PyCFunction)MediaObj_GetMediaTimeScale, 1,
3284      PyDoc_STR("() -> (TimeScale _rv)")},
3285     {"SetMediaTimeScale", (PyCFunction)MediaObj_SetMediaTimeScale, 1,
3286      PyDoc_STR("(TimeScale timeScale) -> None")},
3287     {"GetMediaDuration", (PyCFunction)MediaObj_GetMediaDuration, 1,
3288      PyDoc_STR("() -> (TimeValue _rv)")},
3289     {"GetMediaLanguage", (PyCFunction)MediaObj_GetMediaLanguage, 1,
3290      PyDoc_STR("() -> (short _rv)")},
3291     {"SetMediaLanguage", (PyCFunction)MediaObj_SetMediaLanguage, 1,
3292      PyDoc_STR("(short language) -> None")},
3293     {"GetMediaQuality", (PyCFunction)MediaObj_GetMediaQuality, 1,
3294      PyDoc_STR("() -> (short _rv)")},
3295     {"SetMediaQuality", (PyCFunction)MediaObj_SetMediaQuality, 1,
3296      PyDoc_STR("(short quality) -> None")},
3297     {"GetMediaHandlerDescription", (PyCFunction)MediaObj_GetMediaHandlerDescription, 1,
3298      PyDoc_STR("(Str255 creatorName) -> (OSType mediaType, OSType creatorManufacturer)")},
3299     {"GetMediaUserData", (PyCFunction)MediaObj_GetMediaUserData, 1,
3300      PyDoc_STR("() -> (UserData _rv)")},
3301     {"GetMediaHandler", (PyCFunction)MediaObj_GetMediaHandler, 1,
3302      PyDoc_STR("() -> (MediaHandler _rv)")},
3303     {"SetMediaHandler", (PyCFunction)MediaObj_SetMediaHandler, 1,
3304      PyDoc_STR("(MediaHandlerComponent mH) -> None")},
3305     {"BeginMediaEdits", (PyCFunction)MediaObj_BeginMediaEdits, 1,
3306      PyDoc_STR("() -> None")},
3307     {"EndMediaEdits", (PyCFunction)MediaObj_EndMediaEdits, 1,
3308      PyDoc_STR("() -> None")},
3309     {"SetMediaDefaultDataRefIndex", (PyCFunction)MediaObj_SetMediaDefaultDataRefIndex, 1,
3310      PyDoc_STR("(short index) -> None")},
3311     {"GetMediaDataHandlerDescription", (PyCFunction)MediaObj_GetMediaDataHandlerDescription, 1,
3312      PyDoc_STR("(short index, Str255 creatorName) -> (OSType dhType, OSType creatorManufacturer)")},
3313     {"GetMediaDataHandler", (PyCFunction)MediaObj_GetMediaDataHandler, 1,
3314      PyDoc_STR("(short index) -> (DataHandler _rv)")},
3315     {"SetMediaDataHandler", (PyCFunction)MediaObj_SetMediaDataHandler, 1,
3316      PyDoc_STR("(short index, DataHandlerComponent dataHandler) -> None")},
3317     {"GetMediaSampleDescriptionCount", (PyCFunction)MediaObj_GetMediaSampleDescriptionCount, 1,
3318      PyDoc_STR("() -> (long _rv)")},
3319     {"GetMediaSampleDescription", (PyCFunction)MediaObj_GetMediaSampleDescription, 1,
3320      PyDoc_STR("(long index, SampleDescriptionHandle descH) -> None")},
3321     {"SetMediaSampleDescription", (PyCFunction)MediaObj_SetMediaSampleDescription, 1,
3322      PyDoc_STR("(long index, SampleDescriptionHandle descH) -> None")},
3323     {"GetMediaSampleCount", (PyCFunction)MediaObj_GetMediaSampleCount, 1,
3324      PyDoc_STR("() -> (long _rv)")},
3325     {"GetMediaSyncSampleCount", (PyCFunction)MediaObj_GetMediaSyncSampleCount, 1,
3326      PyDoc_STR("() -> (long _rv)")},
3327     {"SampleNumToMediaTime", (PyCFunction)MediaObj_SampleNumToMediaTime, 1,
3328      PyDoc_STR("(long logicalSampleNum) -> (TimeValue sampleTime, TimeValue sampleDuration)")},
3329     {"MediaTimeToSampleNum", (PyCFunction)MediaObj_MediaTimeToSampleNum, 1,
3330      PyDoc_STR("(TimeValue time) -> (long sampleNum, TimeValue sampleTime, TimeValue sampleDuration)")},
3331     {"AddMediaSample", (PyCFunction)MediaObj_AddMediaSample, 1,
3332      PyDoc_STR("(Handle dataIn, long inOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)")},
3333     {"AddMediaSampleReference", (PyCFunction)MediaObj_AddMediaSampleReference, 1,
3334      PyDoc_STR("(long dataOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)")},
3335     {"GetMediaSample", (PyCFunction)MediaObj_GetMediaSample, 1,
3336      PyDoc_STR("(Handle dataOut, long maxSizeToGrow, TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)")},
3337     {"GetMediaSampleReference", (PyCFunction)MediaObj_GetMediaSampleReference, 1,
3338      PyDoc_STR("(TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long dataOffset, long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)")},
3339     {"SetMediaPreferredChunkSize", (PyCFunction)MediaObj_SetMediaPreferredChunkSize, 1,
3340      PyDoc_STR("(long maxChunkSize) -> None")},
3341     {"GetMediaPreferredChunkSize", (PyCFunction)MediaObj_GetMediaPreferredChunkSize, 1,
3342      PyDoc_STR("() -> (long maxChunkSize)")},
3343     {"SetMediaShadowSync", (PyCFunction)MediaObj_SetMediaShadowSync, 1,
3344      PyDoc_STR("(long frameDiffSampleNum, long syncSampleNum) -> None")},
3345     {"GetMediaShadowSync", (PyCFunction)MediaObj_GetMediaShadowSync, 1,
3346      PyDoc_STR("(long frameDiffSampleNum) -> (long syncSampleNum)")},
3347     {"GetMediaDataSize", (PyCFunction)MediaObj_GetMediaDataSize, 1,
3348      PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (long _rv)")},
3349     {"GetMediaDataSize64", (PyCFunction)MediaObj_GetMediaDataSize64, 1,
3350      PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (wide dataSize)")},
3351     {"CopyMediaUserData", (PyCFunction)MediaObj_CopyMediaUserData, 1,
3352      PyDoc_STR("(Media dstMedia, OSType copyRule) -> None")},
3353     {"GetMediaNextInterestingTime", (PyCFunction)MediaObj_GetMediaNextInterestingTime, 1,
3354      PyDoc_STR("(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)")},
3355     {"GetMediaDataRef", (PyCFunction)MediaObj_GetMediaDataRef, 1,
3356      PyDoc_STR("(short index) -> (Handle dataRef, OSType dataRefType, long dataRefAttributes)")},
3357     {"SetMediaDataRef", (PyCFunction)MediaObj_SetMediaDataRef, 1,
3358      PyDoc_STR("(short index, Handle dataRef, OSType dataRefType) -> None")},
3359     {"SetMediaDataRefAttributes", (PyCFunction)MediaObj_SetMediaDataRefAttributes, 1,
3360      PyDoc_STR("(short index, long dataRefAttributes) -> None")},
3361     {"AddMediaDataRef", (PyCFunction)MediaObj_AddMediaDataRef, 1,
3362      PyDoc_STR("(Handle dataRef, OSType dataRefType) -> (short index)")},
3363     {"GetMediaDataRefCount", (PyCFunction)MediaObj_GetMediaDataRefCount, 1,
3364      PyDoc_STR("() -> (short count)")},
3365     {"SetMediaPlayHints", (PyCFunction)MediaObj_SetMediaPlayHints, 1,
3366      PyDoc_STR("(long flags, long flagsMask) -> None")},
3367     {"GetMediaPlayHints", (PyCFunction)MediaObj_GetMediaPlayHints, 1,
3368      PyDoc_STR("() -> (long flags)")},
3369     {"GetMediaNextInterestingTimeOnly", (PyCFunction)MediaObj_GetMediaNextInterestingTimeOnly, 1,
3370      PyDoc_STR("(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime)")},
3371     {NULL, NULL, 0}
3372 };
3373
3374 #define MediaObj_getsetlist NULL
3375
3376
3377 #define MediaObj_compare NULL
3378
3379 #define MediaObj_repr NULL
3380
3381 #define MediaObj_hash NULL
3382 #define MediaObj_tp_init 0
3383
3384 #define MediaObj_tp_alloc PyType_GenericAlloc
3385
3386 static PyObject *MediaObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
3387 {
3388     PyObject *_self;
3389     Media itself;
3390     char *kw[] = {"itself", 0};
3391
3392     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, MediaObj_Convert, &itself)) return NULL;
3393     if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
3394     ((MediaObject *)_self)->ob_itself = itself;
3395     return _self;
3396 }
3397
3398 #define MediaObj_tp_free PyObject_Del
3399
3400
3401 PyTypeObject Media_Type = {
3402     PyObject_HEAD_INIT(NULL)
3403     0, /*ob_size*/
3404     "_Qt.Media", /*tp_name*/
3405     sizeof(MediaObject), /*tp_basicsize*/
3406     0, /*tp_itemsize*/
3407     /* methods */
3408     (destructor) MediaObj_dealloc, /*tp_dealloc*/
3409     0, /*tp_print*/
3410     (getattrfunc)0, /*tp_getattr*/
3411     (setattrfunc)0, /*tp_setattr*/
3412     (cmpfunc) MediaObj_compare, /*tp_compare*/
3413     (reprfunc) MediaObj_repr, /*tp_repr*/
3414     (PyNumberMethods *)0, /* tp_as_number */
3415     (PySequenceMethods *)0, /* tp_as_sequence */
3416     (PyMappingMethods *)0, /* tp_as_mapping */
3417     (hashfunc) MediaObj_hash, /*tp_hash*/
3418     0, /*tp_call*/
3419     0, /*tp_str*/
3420     PyObject_GenericGetAttr, /*tp_getattro*/
3421     PyObject_GenericSetAttr, /*tp_setattro */
3422     0, /*tp_as_buffer*/
3423     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
3424     0, /*tp_doc*/
3425     0, /*tp_traverse*/
3426     0, /*tp_clear*/
3427     0, /*tp_richcompare*/
3428     0, /*tp_weaklistoffset*/
3429     0, /*tp_iter*/
3430     0, /*tp_iternext*/
3431     MediaObj_methods, /* tp_methods */
3432     0, /*tp_members*/
3433     MediaObj_getsetlist, /*tp_getset*/
3434     0, /*tp_base*/
3435     0, /*tp_dict*/
3436     0, /*tp_descr_get*/
3437     0, /*tp_descr_set*/
3438     0, /*tp_dictoffset*/
3439     MediaObj_tp_init, /* tp_init */
3440     MediaObj_tp_alloc, /* tp_alloc */
3441     MediaObj_tp_new, /* tp_new */
3442     MediaObj_tp_free, /* tp_free */
3443 };
3444
3445 /* --------------------- End object type Media ---------------------- */
3446
3447
3448 /* ----------------------- Object type Track ------------------------ */
3449
3450 PyTypeObject Track_Type;
3451
3452 #define TrackObj_Check(x) ((x)->ob_type == &Track_Type || PyObject_TypeCheck((x), &Track_Type))
3453
3454 typedef struct TrackObject {
3455     PyObject_HEAD
3456     Track ob_itself;
3457 } TrackObject;
3458
3459 PyObject *TrackObj_New(Track itself)
3460 {
3461     TrackObject *it;
3462     if (itself == NULL) {
3463                                     PyErr_SetString(Qt_Error,"Cannot create Track from NULL pointer");
3464                                     return NULL;
3465                             }
3466     it = PyObject_NEW(TrackObject, &Track_Type);
3467     if (it == NULL) return NULL;
3468     it->ob_itself = itself;
3469     return (PyObject *)it;
3470 }
3471
3472 int TrackObj_Convert(PyObject *v, Track *p_itself)
3473 {
3474     if (v == Py_None)
3475     {
3476         *p_itself = NULL;
3477         return 1;
3478     }
3479     if (!TrackObj_Check(v))
3480     {
3481         PyErr_SetString(PyExc_TypeError, "Track required");
3482         return 0;
3483     }
3484     *p_itself = ((TrackObject *)v)->ob_itself;
3485     return 1;
3486 }
3487
3488 static void TrackObj_dealloc(TrackObject *self)
3489 {
3490     if (self->ob_itself) DisposeMovieTrack(self->ob_itself);
3491     self->ob_type->tp_free((PyObject *)self);
3492 }
3493
3494 static PyObject *TrackObj_LoadTrackIntoRam(TrackObject *_self, PyObject *_args)
3495 {
3496     PyObject *_res = NULL;
3497     OSErr _err;
3498     TimeValue time;
3499     TimeValue duration;
3500     long flags;
3501 #ifndef LoadTrackIntoRam
3502     PyMac_PRECHECK(LoadTrackIntoRam);
3503 #endif
3504     if (!PyArg_ParseTuple(_args, "lll",
3505                           &time,
3506                           &duration,
3507                           &flags))
3508         return NULL;
3509     _err = LoadTrackIntoRam(_self->ob_itself,
3510                             time,
3511                             duration,
3512                             flags);
3513     if (_err != noErr) return PyMac_Error(_err);
3514     Py_INCREF(Py_None);
3515     _res = Py_None;
3516     return _res;
3517 }
3518
3519 static PyObject *TrackObj_GetTrackPict(TrackObject *_self, PyObject *_args)
3520 {
3521     PyObject *_res = NULL;
3522     PicHandle _rv;
3523     TimeValue time;
3524 #ifndef GetTrackPict
3525     PyMac_PRECHECK(GetTrackPict);
3526 #endif
3527     if (!PyArg_ParseTuple(_args, "l",
3528                           &time))
3529         return NULL;
3530     _rv = GetTrackPict(_self->ob_itself,
3531                        time);
3532     _res = Py_BuildValue("O&",
3533                          ResObj_New, _rv);
3534     return _res;
3535 }
3536
3537 static PyObject *TrackObj_GetTrackClipRgn(TrackObject *_self, PyObject *_args)
3538 {
3539     PyObject *_res = NULL;
3540     RgnHandle _rv;
3541 #ifndef GetTrackClipRgn
3542     PyMac_PRECHECK(GetTrackClipRgn);
3543 #endif
3544     if (!PyArg_ParseTuple(_args, ""))
3545         return NULL;
3546     _rv = GetTrackClipRgn(_self->ob_itself);
3547     _res = Py_BuildValue("O&",
3548                          ResObj_New, _rv);
3549     return _res;
3550 }
3551
3552 static PyObject *TrackObj_SetTrackClipRgn(TrackObject *_self, PyObject *_args)
3553 {
3554     PyObject *_res = NULL;
3555     RgnHandle theClip;
3556 #ifndef SetTrackClipRgn
3557     PyMac_PRECHECK(SetTrackClipRgn);
3558 #endif
3559     if (!PyArg_ParseTuple(_args, "O&",
3560                           ResObj_Convert, &theClip))
3561         return NULL;
3562     SetTrackClipRgn(_self->ob_itself,
3563                     theClip);
3564     Py_INCREF(Py_None);
3565     _res = Py_None;
3566     return _res;
3567 }
3568
3569 static PyObject *TrackObj_GetTrackDisplayBoundsRgn(TrackObject *_self, PyObject *_args)
3570 {
3571     PyObject *_res = NULL;
3572     RgnHandle _rv;
3573 #ifndef GetTrackDisplayBoundsRgn
3574     PyMac_PRECHECK(GetTrackDisplayBoundsRgn);
3575 #endif
3576     if (!PyArg_ParseTuple(_args, ""))
3577         return NULL;
3578     _rv = GetTrackDisplayBoundsRgn(_self->ob_itself);
3579     _res = Py_BuildValue("O&",
3580                          ResObj_New, _rv);
3581     return _res;
3582 }
3583
3584 static PyObject *TrackObj_GetTrackMovieBoundsRgn(TrackObject *_self, PyObject *_args)
3585 {
3586     PyObject *_res = NULL;
3587     RgnHandle _rv;
3588 #ifndef GetTrackMovieBoundsRgn
3589     PyMac_PRECHECK(GetTrackMovieBoundsRgn);
3590 #endif
3591     if (!PyArg_ParseTuple(_args, ""))
3592         return NULL;
3593     _rv = GetTrackMovieBoundsRgn(_self->ob_itself);
3594     _res = Py_BuildValue("O&",
3595                          ResObj_New, _rv);
3596     return _res;
3597 }
3598
3599 static PyObject *TrackObj_GetTrackBoundsRgn(TrackObject *_self, PyObject *_args)
3600 {
3601     PyObject *_res = NULL;
3602     RgnHandle _rv;
3603 #ifndef GetTrackBoundsRgn
3604     PyMac_PRECHECK(GetTrackBoundsRgn);
3605 #endif
3606     if (!PyArg_ParseTuple(_args, ""))
3607         return NULL;
3608     _rv = GetTrackBoundsRgn(_self->ob_itself);
3609     _res = Py_BuildValue("O&",
3610                          ResObj_New, _rv);
3611     return _res;
3612 }
3613
3614 static PyObject *TrackObj_GetTrackMatte(TrackObject *_self, PyObject *_args)
3615 {
3616     PyObject *_res = NULL;
3617     PixMapHandle _rv;
3618 #ifndef GetTrackMatte
3619     PyMac_PRECHECK(GetTrackMatte);
3620 #endif
3621     if (!PyArg_ParseTuple(_args, ""))
3622         return NULL;
3623     _rv = GetTrackMatte(_self->ob_itself);
3624     _res = Py_BuildValue("O&",
3625                          ResObj_New, _rv);
3626     return _res;
3627 }
3628
3629 static PyObject *TrackObj_SetTrackMatte(TrackObject *_self, PyObject *_args)
3630 {
3631     PyObject *_res = NULL;
3632     PixMapHandle theMatte;
3633 #ifndef SetTrackMatte
3634     PyMac_PRECHECK(SetTrackMatte);
3635 #endif
3636     if (!PyArg_ParseTuple(_args, "O&",
3637                           ResObj_Convert, &theMatte))
3638         return NULL;
3639     SetTrackMatte(_self->ob_itself,
3640                   theMatte);
3641     Py_INCREF(Py_None);
3642     _res = Py_None;
3643     return _res;
3644 }
3645
3646 static PyObject *TrackObj_GetTrackID(TrackObject *_self, PyObject *_args)
3647 {
3648     PyObject *_res = NULL;
3649     long _rv;
3650 #ifndef GetTrackID
3651     PyMac_PRECHECK(GetTrackID);
3652 #endif
3653     if (!PyArg_ParseTuple(_args, ""))
3654         return NULL;
3655     _rv = GetTrackID(_self->ob_itself);
3656     _res = Py_BuildValue("l",
3657                          _rv);
3658     return _res;
3659 }
3660
3661 static PyObject *TrackObj_GetTrackMovie(TrackObject *_self, PyObject *_args)
3662 {
3663     PyObject *_res = NULL;
3664     Movie _rv;
3665 #ifndef GetTrackMovie
3666     PyMac_PRECHECK(GetTrackMovie);
3667 #endif
3668     if (!PyArg_ParseTuple(_args, ""))
3669         return NULL;
3670     _rv = GetTrackMovie(_self->ob_itself);
3671     _res = Py_BuildValue("O&",
3672                          MovieObj_New, _rv);
3673     return _res;
3674 }
3675
3676 static PyObject *TrackObj_GetTrackCreationTime(TrackObject *_self, PyObject *_args)
3677 {
3678     PyObject *_res = NULL;
3679     unsigned long _rv;
3680 #ifndef GetTrackCreationTime
3681     PyMac_PRECHECK(GetTrackCreationTime);
3682 #endif
3683     if (!PyArg_ParseTuple(_args, ""))
3684         return NULL;
3685     _rv = GetTrackCreationTime(_self->ob_itself);
3686     _res = Py_BuildValue("l",
3687                          _rv);
3688     return _res;
3689 }
3690
3691 static PyObject *TrackObj_GetTrackModificationTime(TrackObject *_self, PyObject *_args)
3692 {
3693     PyObject *_res = NULL;
3694     unsigned long _rv;
3695 #ifndef GetTrackModificationTime
3696     PyMac_PRECHECK(GetTrackModificationTime);
3697 #endif
3698     if (!PyArg_ParseTuple(_args, ""))
3699         return NULL;
3700     _rv = GetTrackModificationTime(_self->ob_itself);
3701     _res = Py_BuildValue("l",
3702                          _rv);
3703     return _res;
3704 }
3705
3706 static PyObject *TrackObj_GetTrackEnabled(TrackObject *_self, PyObject *_args)
3707 {
3708     PyObject *_res = NULL;
3709     Boolean _rv;
3710 #ifndef GetTrackEnabled
3711     PyMac_PRECHECK(GetTrackEnabled);
3712 #endif
3713     if (!PyArg_ParseTuple(_args, ""))
3714         return NULL;
3715     _rv = GetTrackEnabled(_self->ob_itself);
3716     _res = Py_BuildValue("b",
3717                          _rv);
3718     return _res;
3719 }
3720
3721 static PyObject *TrackObj_SetTrackEnabled(TrackObject *_self, PyObject *_args)
3722 {
3723     PyObject *_res = NULL;
3724     Boolean isEnabled;
3725 #ifndef SetTrackEnabled
3726     PyMac_PRECHECK(SetTrackEnabled);
3727 #endif
3728     if (!PyArg_ParseTuple(_args, "b",
3729                           &isEnabled))
3730         return NULL;
3731     SetTrackEnabled(_self->ob_itself,
3732                     isEnabled);
3733     Py_INCREF(Py_None);
3734     _res = Py_None;
3735     return _res;
3736 }
3737
3738 static PyObject *TrackObj_GetTrackUsage(TrackObject *_self, PyObject *_args)
3739 {
3740     PyObject *_res = NULL;
3741     long _rv;
3742 #ifndef GetTrackUsage
3743     PyMac_PRECHECK(GetTrackUsage);
3744 #endif
3745     if (!PyArg_ParseTuple(_args, ""))
3746         return NULL;
3747     _rv = GetTrackUsage(_self->ob_itself);
3748     _res = Py_BuildValue("l",
3749                          _rv);
3750     return _res;
3751 }
3752
3753 static PyObject *TrackObj_SetTrackUsage(TrackObject *_self, PyObject *_args)
3754 {
3755     PyObject *_res = NULL;
3756     long usage;
3757 #ifndef SetTrackUsage
3758     PyMac_PRECHECK(SetTrackUsage);
3759 #endif
3760     if (!PyArg_ParseTuple(_args, "l",
3761                           &usage))
3762         return NULL;
3763     SetTrackUsage(_self->ob_itself,
3764                   usage);
3765     Py_INCREF(Py_None);
3766     _res = Py_None;
3767     return _res;
3768 }
3769
3770 static PyObject *TrackObj_GetTrackDuration(TrackObject *_self, PyObject *_args)
3771 {
3772     PyObject *_res = NULL;
3773     TimeValue _rv;
3774 #ifndef GetTrackDuration
3775     PyMac_PRECHECK(GetTrackDuration);
3776 #endif
3777     if (!PyArg_ParseTuple(_args, ""))
3778         return NULL;
3779     _rv = GetTrackDuration(_self->ob_itself);
3780     _res = Py_BuildValue("l",
3781                          _rv);
3782     return _res;
3783 }
3784
3785 static PyObject *TrackObj_GetTrackOffset(TrackObject *_self, PyObject *_args)
3786 {
3787     PyObject *_res = NULL;
3788     TimeValue _rv;
3789 #ifndef GetTrackOffset
3790     PyMac_PRECHECK(GetTrackOffset);
3791 #endif
3792     if (!PyArg_ParseTuple(_args, ""))
3793         return NULL;
3794     _rv = GetTrackOffset(_self->ob_itself);
3795     _res = Py_BuildValue("l",
3796                          _rv);
3797     return _res;
3798 }
3799
3800 static PyObject *TrackObj_SetTrackOffset(TrackObject *_self, PyObject *_args)
3801 {
3802     PyObject *_res = NULL;
3803     TimeValue movieOffsetTime;
3804 #ifndef SetTrackOffset
3805     PyMac_PRECHECK(SetTrackOffset);
3806 #endif
3807     if (!PyArg_ParseTuple(_args, "l",
3808                           &movieOffsetTime))
3809         return NULL;
3810     SetTrackOffset(_self->ob_itself,
3811                    movieOffsetTime);
3812     Py_INCREF(Py_None);
3813     _res = Py_None;
3814     return _res;
3815 }
3816
3817 static PyObject *TrackObj_GetTrackLayer(TrackObject *_self, PyObject *_args)
3818 {
3819     PyObject *_res = NULL;
3820     short _rv;
3821 #ifndef GetTrackLayer
3822     PyMac_PRECHECK(GetTrackLayer);
3823 #endif
3824     if (!PyArg_ParseTuple(_args, ""))
3825         return NULL;
3826     _rv = GetTrackLayer(_self->ob_itself);
3827     _res = Py_BuildValue("h",
3828                          _rv);
3829     return _res;
3830 }
3831
3832 static PyObject *TrackObj_SetTrackLayer(TrackObject *_self, PyObject *_args)
3833 {
3834     PyObject *_res = NULL;
3835     short layer;
3836 #ifndef SetTrackLayer
3837     PyMac_PRECHECK(SetTrackLayer);
3838 #endif
3839     if (!PyArg_ParseTuple(_args, "h",
3840                           &layer))
3841         return NULL;
3842     SetTrackLayer(_self->ob_itself,
3843                   layer);
3844     Py_INCREF(Py_None);
3845     _res = Py_None;
3846     return _res;
3847 }
3848
3849 static PyObject *TrackObj_GetTrackAlternate(TrackObject *_self, PyObject *_args)
3850 {
3851     PyObject *_res = NULL;
3852     Track _rv;
3853 #ifndef GetTrackAlternate
3854     PyMac_PRECHECK(GetTrackAlternate);
3855 #endif
3856     if (!PyArg_ParseTuple(_args, ""))
3857         return NULL;
3858     _rv = GetTrackAlternate(_self->ob_itself);
3859     _res = Py_BuildValue("O&",
3860                          TrackObj_New, _rv);
3861     return _res;
3862 }
3863
3864 static PyObject *TrackObj_SetTrackAlternate(TrackObject *_self, PyObject *_args)
3865 {
3866     PyObject *_res = NULL;
3867     Track alternateT;
3868 #ifndef SetTrackAlternate
3869     PyMac_PRECHECK(SetTrackAlternate);
3870 #endif
3871     if (!PyArg_ParseTuple(_args, "O&",
3872                           TrackObj_Convert, &alternateT))
3873         return NULL;
3874     SetTrackAlternate(_self->ob_itself,
3875                       alternateT);
3876     Py_INCREF(Py_None);
3877     _res = Py_None;
3878     return _res;
3879 }
3880
3881 static PyObject *TrackObj_GetTrackVolume(TrackObject *_self, PyObject *_args)
3882 {
3883     PyObject *_res = NULL;
3884     short _rv;
3885 #ifndef GetTrackVolume
3886     PyMac_PRECHECK(GetTrackVolume);
3887 #endif
3888     if (!PyArg_ParseTuple(_args, ""))
3889         return NULL;
3890     _rv = GetTrackVolume(_self->ob_itself);
3891     _res = Py_BuildValue("h",
3892                          _rv);
3893     return _res;
3894 }
3895
3896 static PyObject *TrackObj_SetTrackVolume(TrackObject *_self, PyObject *_args)
3897 {
3898     PyObject *_res = NULL;
3899     short volume;
3900 #ifndef SetTrackVolume
3901     PyMac_PRECHECK(SetTrackVolume);
3902 #endif
3903     if (!PyArg_ParseTuple(_args, "h",
3904                           &volume))
3905         return NULL;
3906     SetTrackVolume(_self->ob_itself,
3907                    volume);
3908     Py_INCREF(Py_None);
3909     _res = Py_None;
3910     return _res;
3911 }
3912
3913 static PyObject *TrackObj_GetTrackDimensions(TrackObject *_self, PyObject *_args)
3914 {
3915     PyObject *_res = NULL;
3916     Fixed width;
3917     Fixed height;
3918 #ifndef GetTrackDimensions
3919     PyMac_PRECHECK(GetTrackDimensions);
3920 #endif
3921     if (!PyArg_ParseTuple(_args, ""))
3922         return NULL;
3923     GetTrackDimensions(_self->ob_itself,
3924                        &width,
3925                        &height);
3926     _res = Py_BuildValue("O&O&",
3927                          PyMac_BuildFixed, width,
3928                          PyMac_BuildFixed, height);
3929     return _res;
3930 }
3931
3932 static PyObject *TrackObj_SetTrackDimensions(TrackObject *_self, PyObject *_args)
3933 {
3934     PyObject *_res = NULL;
3935     Fixed width;
3936     Fixed height;
3937 #ifndef SetTrackDimensions
3938     PyMac_PRECHECK(SetTrackDimensions);
3939 #endif
3940     if (!PyArg_ParseTuple(_args, "O&O&",
3941                           PyMac_GetFixed, &width,
3942                           PyMac_GetFixed, &height))
3943         return NULL;
3944     SetTrackDimensions(_self->ob_itself,
3945                        width,
3946                        height);
3947     Py_INCREF(Py_None);
3948     _res = Py_None;
3949     return _res;
3950 }
3951
3952 static PyObject *TrackObj_GetTrackUserData(TrackObject *_self, PyObject *_args)
3953 {
3954     PyObject *_res = NULL;
3955     UserData _rv;
3956 #ifndef GetTrackUserData
3957     PyMac_PRECHECK(GetTrackUserData);
3958 #endif
3959     if (!PyArg_ParseTuple(_args, ""))
3960         return NULL;
3961     _rv = GetTrackUserData(_self->ob_itself);
3962     _res = Py_BuildValue("O&",
3963                          UserDataObj_New, _rv);
3964     return _res;
3965 }
3966
3967 static PyObject *TrackObj_GetTrackSoundLocalizationSettings(TrackObject *_self, PyObject *_args)
3968 {
3969     PyObject *_res = NULL;
3970     OSErr _err;
3971     Handle settings;
3972 #ifndef GetTrackSoundLocalizationSettings
3973     PyMac_PRECHECK(GetTrackSoundLocalizationSettings);
3974 #endif
3975     if (!PyArg_ParseTuple(_args, ""))
3976         return NULL;
3977     _err = GetTrackSoundLocalizationSettings(_self->ob_itself,
3978                                              &settings);
3979     if (_err != noErr) return PyMac_Error(_err);
3980     _res = Py_BuildValue("O&",
3981                          ResObj_New, settings);
3982     return _res;
3983 }
3984
3985 static PyObject *TrackObj_SetTrackSoundLocalizationSettings(TrackObject *_self, PyObject *_args)
3986 {
3987     PyObject *_res = NULL;
3988     OSErr _err;
3989     Handle settings;
3990 #ifndef SetTrackSoundLocalizationSettings
3991     PyMac_PRECHECK(SetTrackSoundLocalizationSettings);
3992 #endif
3993     if (!PyArg_ParseTuple(_args, "O&",
3994                           ResObj_Convert, &settings))
3995         return NULL;
3996     _err = SetTrackSoundLocalizationSettings(_self->ob_itself,
3997                                              settings);
3998     if (_err != noErr) return PyMac_Error(_err);
3999     Py_INCREF(Py_None);
4000     _res = Py_None;
4001     return _res;
4002 }
4003
4004 static PyObject *TrackObj_NewTrackMedia(TrackObject *_self, PyObject *_args)
4005 {
4006     PyObject *_res = NULL;
4007     Media _rv;
4008     OSType mediaType;
4009     TimeScale timeScale;
4010     Handle dataRef;
4011     OSType dataRefType;
4012 #ifndef NewTrackMedia
4013     PyMac_PRECHECK(NewTrackMedia);
4014 #endif
4015     if (!PyArg_ParseTuple(_args, "O&lO&O&",
4016                           PyMac_GetOSType, &mediaType,
4017                           &timeScale,
4018                           ResObj_Convert, &dataRef,
4019                           PyMac_GetOSType, &dataRefType))
4020         return NULL;
4021     _rv = NewTrackMedia(_self->ob_itself,
4022                         mediaType,
4023                         timeScale,
4024                         dataRef,
4025                         dataRefType);
4026     _res = Py_BuildValue("O&",
4027                          MediaObj_New, _rv);
4028     return _res;
4029 }
4030
4031 static PyObject *TrackObj_GetTrackMedia(TrackObject *_self, PyObject *_args)
4032 {
4033     PyObject *_res = NULL;
4034     Media _rv;
4035 #ifndef GetTrackMedia
4036     PyMac_PRECHECK(GetTrackMedia);
4037 #endif
4038     if (!PyArg_ParseTuple(_args, ""))
4039         return NULL;
4040     _rv = GetTrackMedia(_self->ob_itself);
4041     _res = Py_BuildValue("O&",
4042                          MediaObj_New, _rv);
4043     return _res;
4044 }
4045
4046 static PyObject *TrackObj_InsertMediaIntoTrack(TrackObject *_self, PyObject *_args)
4047 {
4048     PyObject *_res = NULL;
4049     OSErr _err;
4050     TimeValue trackStart;
4051     TimeValue mediaTime;
4052     TimeValue mediaDuration;
4053     Fixed mediaRate;
4054 #ifndef InsertMediaIntoTrack
4055     PyMac_PRECHECK(InsertMediaIntoTrack);
4056 #endif
4057     if (!PyArg_ParseTuple(_args, "lllO&",
4058                           &trackStart,
4059                           &mediaTime,
4060                           &mediaDuration,
4061                           PyMac_GetFixed, &mediaRate))
4062         return NULL;
4063     _err = InsertMediaIntoTrack(_self->ob_itself,
4064                                 trackStart,
4065                                 mediaTime,
4066                                 mediaDuration,
4067                                 mediaRate);
4068     if (_err != noErr) return PyMac_Error(_err);
4069     Py_INCREF(Py_None);
4070     _res = Py_None;
4071     return _res;
4072 }
4073
4074 static PyObject *TrackObj_InsertTrackSegment(TrackObject *_self, PyObject *_args)
4075 {
4076     PyObject *_res = NULL;
4077     OSErr _err;
4078     Track dstTrack;
4079     TimeValue srcIn;
4080     TimeValue srcDuration;
4081     TimeValue dstIn;
4082 #ifndef InsertTrackSegment
4083     PyMac_PRECHECK(InsertTrackSegment);
4084 #endif
4085     if (!PyArg_ParseTuple(_args, "O&lll",
4086                           TrackObj_Convert, &dstTrack,
4087                           &srcIn,
4088                           &srcDuration,
4089                           &dstIn))
4090         return NULL;
4091     _err = InsertTrackSegment(_self->ob_itself,
4092                               dstTrack,
4093                               srcIn,
4094                               srcDuration,
4095                               dstIn);
4096     if (_err != noErr) return PyMac_Error(_err);
4097     Py_INCREF(Py_None);
4098     _res = Py_None;
4099     return _res;
4100 }
4101
4102 static PyObject *TrackObj_InsertEmptyTrackSegment(TrackObject *_self, PyObject *_args)
4103 {
4104     PyObject *_res = NULL;
4105     OSErr _err;
4106     TimeValue dstIn;
4107     TimeValue dstDuration;
4108 #ifndef InsertEmptyTrackSegment
4109     PyMac_PRECHECK(InsertEmptyTrackSegment);
4110 #endif
4111     if (!PyArg_ParseTuple(_args, "ll",
4112                           &dstIn,
4113                           &dstDuration))
4114         return NULL;
4115     _err = InsertEmptyTrackSegment(_self->ob_itself,
4116                                    dstIn,
4117                                    dstDuration);
4118     if (_err != noErr) return PyMac_Error(_err);
4119     Py_INCREF(Py_None);
4120     _res = Py_None;
4121     return _res;
4122 }
4123
4124 static PyObject *TrackObj_DeleteTrackSegment(TrackObject *_self, PyObject *_args)
4125 {
4126     PyObject *_res = NULL;
4127     OSErr _err;
4128     TimeValue startTime;
4129     TimeValue duration;
4130 #ifndef DeleteTrackSegment
4131     PyMac_PRECHECK(DeleteTrackSegment);
4132 #endif
4133     if (!PyArg_ParseTuple(_args, "ll",
4134                           &startTime,
4135                           &duration))
4136         return NULL;
4137     _err = DeleteTrackSegment(_self->ob_itself,
4138                               startTime,
4139                               duration);
4140     if (_err != noErr) return PyMac_Error(_err);
4141     Py_INCREF(Py_None);
4142     _res = Py_None;
4143     return _res;
4144 }
4145
4146 static PyObject *TrackObj_ScaleTrackSegment(TrackObject *_self, PyObject *_args)
4147 {
4148     PyObject *_res = NULL;
4149     OSErr _err;
4150     TimeValue startTime;
4151     TimeValue oldDuration;
4152     TimeValue newDuration;
4153 #ifndef ScaleTrackSegment
4154     PyMac_PRECHECK(ScaleTrackSegment);
4155 #endif
4156     if (!PyArg_ParseTuple(_args, "lll",
4157                           &startTime,
4158                           &oldDuration,
4159                           &newDuration))
4160         return NULL;
4161     _err = ScaleTrackSegment(_self->ob_itself,
4162                              startTime,
4163                              oldDuration,
4164                              newDuration);
4165     if (_err != noErr) return PyMac_Error(_err);
4166     Py_INCREF(Py_None);
4167     _res = Py_None;
4168     return _res;
4169 }
4170
4171 static PyObject *TrackObj_IsScrapMovie(TrackObject *_self, PyObject *_args)
4172 {
4173     PyObject *_res = NULL;
4174     Component _rv;
4175 #ifndef IsScrapMovie
4176     PyMac_PRECHECK(IsScrapMovie);
4177 #endif
4178     if (!PyArg_ParseTuple(_args, ""))
4179         return NULL;
4180     _rv = IsScrapMovie(_self->ob_itself);
4181     _res = Py_BuildValue("O&",
4182                          CmpObj_New, _rv);
4183     return _res;
4184 }
4185
4186 static PyObject *TrackObj_CopyTrackSettings(TrackObject *_self, PyObject *_args)
4187 {
4188     PyObject *_res = NULL;
4189     OSErr _err;
4190     Track dstTrack;
4191 #ifndef CopyTrackSettings
4192     PyMac_PRECHECK(CopyTrackSettings);
4193 #endif
4194     if (!PyArg_ParseTuple(_args, "O&",
4195                           TrackObj_Convert, &dstTrack))
4196         return NULL;
4197     _err = CopyTrackSettings(_self->ob_itself,
4198                              dstTrack);
4199     if (_err != noErr) return PyMac_Error(_err);
4200     Py_INCREF(Py_None);
4201     _res = Py_None;
4202     return _res;
4203 }
4204
4205 static PyObject *TrackObj_AddEmptyTrackToMovie(TrackObject *_self, PyObject *_args)
4206 {
4207     PyObject *_res = NULL;
4208     OSErr _err;
4209     Movie dstMovie;
4210     Handle dataRef;
4211     OSType dataRefType;
4212     Track dstTrack;
4213 #ifndef AddEmptyTrackToMovie
4214     PyMac_PRECHECK(AddEmptyTrackToMovie);
4215 #endif
4216     if (!PyArg_ParseTuple(_args, "O&O&O&",
4217                           MovieObj_Convert, &dstMovie,
4218                           ResObj_Convert, &dataRef,
4219                           PyMac_GetOSType, &dataRefType))
4220         return NULL;
4221     _err = AddEmptyTrackToMovie(_self->ob_itself,
4222                                 dstMovie,
4223                                 dataRef,
4224                                 dataRefType,
4225                                 &dstTrack);
4226     if (_err != noErr) return PyMac_Error(_err);
4227     _res = Py_BuildValue("O&",
4228                          TrackObj_New, dstTrack);
4229     return _res;
4230 }
4231
4232 static PyObject *TrackObj_AddClonedTrackToMovie(TrackObject *_self, PyObject *_args)
4233 {
4234     PyObject *_res = NULL;
4235     OSErr _err;
4236     Movie dstMovie;
4237     long flags;
4238     Track dstTrack;
4239 #ifndef AddClonedTrackToMovie
4240     PyMac_PRECHECK(AddClonedTrackToMovie);
4241 #endif
4242     if (!PyArg_ParseTuple(_args, "O&l",
4243                           MovieObj_Convert, &dstMovie,
4244                           &flags))
4245         return NULL;
4246     _err = AddClonedTrackToMovie(_self->ob_itself,
4247                                  dstMovie,
4248                                  flags,
4249                                  &dstTrack);
4250     if (_err != noErr) return PyMac_Error(_err);
4251     _res = Py_BuildValue("O&",
4252                          TrackObj_New, dstTrack);
4253     return _res;
4254 }
4255
4256 static PyObject *TrackObj_AddTrackReference(TrackObject *_self, PyObject *_args)
4257 {
4258     PyObject *_res = NULL;
4259     OSErr _err;
4260     Track refTrack;
4261     OSType refType;
4262     long addedIndex;
4263 #ifndef AddTrackReference
4264     PyMac_PRECHECK(AddTrackReference);
4265 #endif
4266     if (!PyArg_ParseTuple(_args, "O&O&",
4267                           TrackObj_Convert, &refTrack,
4268                           PyMac_GetOSType, &refType))
4269         return NULL;
4270     _err = AddTrackReference(_self->ob_itself,
4271                              refTrack,
4272                              refType,
4273                              &addedIndex);
4274     if (_err != noErr) return PyMac_Error(_err);
4275     _res = Py_BuildValue("l",
4276                          addedIndex);
4277     return _res;
4278 }
4279
4280 static PyObject *TrackObj_DeleteTrackReference(TrackObject *_self, PyObject *_args)
4281 {
4282     PyObject *_res = NULL;
4283     OSErr _err;
4284     OSType refType;
4285     long index;
4286 #ifndef DeleteTrackReference
4287     PyMac_PRECHECK(DeleteTrackReference);
4288 #endif
4289     if (!PyArg_ParseTuple(_args, "O&l",
4290                           PyMac_GetOSType, &refType,
4291                           &index))
4292         return NULL;
4293     _err = DeleteTrackReference(_self->ob_itself,
4294                                 refType,
4295                                 index);
4296     if (_err != noErr) return PyMac_Error(_err);
4297     Py_INCREF(Py_None);
4298     _res = Py_None;
4299     return _res;
4300 }
4301
4302 static PyObject *TrackObj_SetTrackReference(TrackObject *_self, PyObject *_args)
4303 {
4304     PyObject *_res = NULL;
4305     OSErr _err;
4306     Track refTrack;
4307     OSType refType;
4308     long index;
4309 #ifndef SetTrackReference
4310     PyMac_PRECHECK(SetTrackReference);
4311 #endif
4312     if (!PyArg_ParseTuple(_args, "O&O&l",
4313                           TrackObj_Convert, &refTrack,
4314                           PyMac_GetOSType, &refType,
4315                           &index))
4316         return NULL;
4317     _err = SetTrackReference(_self->ob_itself,
4318                              refTrack,
4319                              refType,
4320                              index);
4321     if (_err != noErr) return PyMac_Error(_err);
4322     Py_INCREF(Py_None);
4323     _res = Py_None;
4324     return _res;
4325 }
4326
4327 static PyObject *TrackObj_GetTrackReference(TrackObject *_self, PyObject *_args)
4328 {
4329     PyObject *_res = NULL;
4330     Track _rv;
4331     OSType refType;
4332     long index;
4333 #ifndef GetTrackReference
4334     PyMac_PRECHECK(GetTrackReference);
4335 #endif
4336     if (!PyArg_ParseTuple(_args, "O&l",
4337                           PyMac_GetOSType, &refType,
4338                           &index))
4339         return NULL;
4340     _rv = GetTrackReference(_self->ob_itself,
4341                             refType,
4342                             index);
4343     _res = Py_BuildValue("O&",
4344                          TrackObj_New, _rv);
4345     return _res;
4346 }
4347
4348 static PyObject *TrackObj_GetNextTrackReferenceType(TrackObject *_self, PyObject *_args)
4349 {
4350     PyObject *_res = NULL;
4351     OSType _rv;
4352     OSType refType;
4353 #ifndef GetNextTrackReferenceType
4354     PyMac_PRECHECK(GetNextTrackReferenceType);
4355 #endif
4356     if (!PyArg_ParseTuple(_args, "O&",
4357                           PyMac_GetOSType, &refType))
4358         return NULL;
4359     _rv = GetNextTrackReferenceType(_self->ob_itself,
4360                                     refType);
4361     _res = Py_BuildValue("O&",
4362                          PyMac_BuildOSType, _rv);
4363     return _res;
4364 }
4365
4366 static PyObject *TrackObj_GetTrackReferenceCount(TrackObject *_self, PyObject *_args)
4367 {
4368     PyObject *_res = NULL;
4369     long _rv;
4370     OSType refType;
4371 #ifndef GetTrackReferenceCount
4372     PyMac_PRECHECK(GetTrackReferenceCount);
4373 #endif
4374     if (!PyArg_ParseTuple(_args, "O&",
4375                           PyMac_GetOSType, &refType))
4376         return NULL;
4377     _rv = GetTrackReferenceCount(_self->ob_itself,
4378                                  refType);
4379     _res = Py_BuildValue("l",
4380                          _rv);
4381     return _res;
4382 }
4383
4384 static PyObject *TrackObj_GetTrackEditRate(TrackObject *_self, PyObject *_args)
4385 {
4386     PyObject *_res = NULL;
4387     Fixed _rv;
4388     TimeValue atTime;
4389 #ifndef GetTrackEditRate
4390     PyMac_PRECHECK(GetTrackEditRate);
4391 #endif
4392     if (!PyArg_ParseTuple(_args, "l",
4393                           &atTime))
4394         return NULL;
4395     _rv = GetTrackEditRate(_self->ob_itself,
4396                            atTime);
4397     _res = Py_BuildValue("O&",
4398                          PyMac_BuildFixed, _rv);
4399     return _res;
4400 }
4401
4402 static PyObject *TrackObj_GetTrackDataSize(TrackObject *_self, PyObject *_args)
4403 {
4404     PyObject *_res = NULL;
4405     long _rv;
4406     TimeValue startTime;
4407     TimeValue duration;
4408 #ifndef GetTrackDataSize
4409     PyMac_PRECHECK(GetTrackDataSize);
4410 #endif
4411     if (!PyArg_ParseTuple(_args, "ll",
4412                           &startTime,
4413                           &duration))
4414         return NULL;
4415     _rv = GetTrackDataSize(_self->ob_itself,
4416                            startTime,
4417                            duration);
4418     _res = Py_BuildValue("l",
4419                          _rv);
4420     return _res;
4421 }
4422
4423 static PyObject *TrackObj_GetTrackDataSize64(TrackObject *_self, PyObject *_args)
4424 {
4425     PyObject *_res = NULL;
4426     OSErr _err;
4427     TimeValue startTime;
4428     TimeValue duration;
4429     wide dataSize;
4430 #ifndef GetTrackDataSize64
4431     PyMac_PRECHECK(GetTrackDataSize64);
4432 #endif
4433     if (!PyArg_ParseTuple(_args, "ll",
4434                           &startTime,
4435                           &duration))
4436         return NULL;
4437     _err = GetTrackDataSize64(_self->ob_itself,
4438                               startTime,
4439                               duration,
4440                               &dataSize);
4441     if (_err != noErr) return PyMac_Error(_err);
4442     _res = Py_BuildValue("O&",
4443                          PyMac_Buildwide, dataSize);
4444     return _res;
4445 }
4446
4447 static PyObject *TrackObj_PtInTrack(TrackObject *_self, PyObject *_args)
4448 {
4449     PyObject *_res = NULL;
4450     Boolean _rv;
4451     Point pt;
4452 #ifndef PtInTrack
4453     PyMac_PRECHECK(PtInTrack);
4454 #endif
4455     if (!PyArg_ParseTuple(_args, "O&",
4456                           PyMac_GetPoint, &pt))
4457         return NULL;
4458     _rv = PtInTrack(_self->ob_itself,
4459                     pt);
4460     _res = Py_BuildValue("b",
4461                          _rv);
4462     return _res;
4463 }
4464
4465 static PyObject *TrackObj_CopyTrackUserData(TrackObject *_self, PyObject *_args)
4466 {
4467     PyObject *_res = NULL;
4468     OSErr _err;
4469     Track dstTrack;
4470     OSType copyRule;
4471 #ifndef CopyTrackUserData
4472     PyMac_PRECHECK(CopyTrackUserData);
4473 #endif
4474     if (!PyArg_ParseTuple(_args, "O&O&",
4475                           TrackObj_Convert, &dstTrack,
4476                           PyMac_GetOSType, &copyRule))
4477         return NULL;
4478     _err = CopyTrackUserData(_self->ob_itself,
4479                              dstTrack,
4480                              copyRule);
4481     if (_err != noErr) return PyMac_Error(_err);
4482     Py_INCREF(Py_None);
4483     _res = Py_None;
4484     return _res;
4485 }
4486
4487 static PyObject *TrackObj_GetTrackNextInterestingTime(TrackObject *_self, PyObject *_args)
4488 {
4489     PyObject *_res = NULL;
4490     short interestingTimeFlags;
4491     TimeValue time;
4492     Fixed rate;
4493     TimeValue interestingTime;
4494     TimeValue interestingDuration;
4495 #ifndef GetTrackNextInterestingTime
4496     PyMac_PRECHECK(GetTrackNextInterestingTime);
4497 #endif
4498     if (!PyArg_ParseTuple(_args, "hlO&",
4499                           &interestingTimeFlags,
4500                           &time,
4501                           PyMac_GetFixed, &rate))
4502         return NULL;
4503     GetTrackNextInterestingTime(_self->ob_itself,
4504                                 interestingTimeFlags,
4505                                 time,
4506                                 rate,
4507                                 &interestingTime,
4508                                 &interestingDuration);
4509     _res = Py_BuildValue("ll",
4510                          interestingTime,
4511                          interestingDuration);
4512     return _res;
4513 }
4514
4515 static PyObject *TrackObj_GetTrackSegmentDisplayBoundsRgn(TrackObject *_self, PyObject *_args)
4516 {
4517     PyObject *_res = NULL;
4518     RgnHandle _rv;
4519     TimeValue time;
4520     TimeValue duration;
4521 #ifndef GetTrackSegmentDisplayBoundsRgn
4522     PyMac_PRECHECK(GetTrackSegmentDisplayBoundsRgn);
4523 #endif
4524     if (!PyArg_ParseTuple(_args, "ll",
4525                           &time,
4526                           &duration))
4527         return NULL;
4528     _rv = GetTrackSegmentDisplayBoundsRgn(_self->ob_itself,
4529                                           time,
4530                                           duration);
4531     _res = Py_BuildValue("O&",
4532                          ResObj_New, _rv);
4533     return _res;
4534 }
4535
4536 static PyObject *TrackObj_GetTrackStatus(TrackObject *_self, PyObject *_args)
4537 {
4538     PyObject *_res = NULL;
4539     ComponentResult _rv;
4540 #ifndef GetTrackStatus
4541     PyMac_PRECHECK(GetTrackStatus);
4542 #endif
4543     if (!PyArg_ParseTuple(_args, ""))
4544         return NULL;
4545     _rv = GetTrackStatus(_self->ob_itself);
4546     _res = Py_BuildValue("l",
4547                          _rv);
4548     return _res;
4549 }
4550
4551 static PyObject *TrackObj_SetTrackLoadSettings(TrackObject *_self, PyObject *_args)
4552 {
4553     PyObject *_res = NULL;
4554     TimeValue preloadTime;
4555     TimeValue preloadDuration;
4556     long preloadFlags;
4557     long defaultHints;
4558 #ifndef SetTrackLoadSettings
4559     PyMac_PRECHECK(SetTrackLoadSettings);
4560 #endif
4561     if (!PyArg_ParseTuple(_args, "llll",
4562                           &preloadTime,
4563                           &preloadDuration,
4564                           &preloadFlags,
4565                           &defaultHints))
4566         return NULL;
4567     SetTrackLoadSettings(_self->ob_itself,
4568                          preloadTime,
4569                          preloadDuration,
4570                          preloadFlags,
4571                          defaultHints);
4572     Py_INCREF(Py_None);
4573     _res = Py_None;
4574     return _res;
4575 }
4576
4577 static PyObject *TrackObj_GetTrackLoadSettings(TrackObject *_self, PyObject *_args)
4578 {
4579     PyObject *_res = NULL;
4580     TimeValue preloadTime;
4581     TimeValue preloadDuration;
4582     long preloadFlags;
4583     long defaultHints;
4584 #ifndef GetTrackLoadSettings
4585     PyMac_PRECHECK(GetTrackLoadSettings);
4586 #endif
4587     if (!PyArg_ParseTuple(_args, ""))
4588         return NULL;
4589     GetTrackLoadSettings(_self->ob_itself,
4590                          &preloadTime,
4591                          &preloadDuration,
4592                          &preloadFlags,
4593                          &defaultHints);
4594     _res = Py_BuildValue("llll",
4595                          preloadTime,
4596                          preloadDuration,
4597                          preloadFlags,
4598                          defaultHints);
4599     return _res;
4600 }
4601
4602 static PyMethodDef TrackObj_methods[] = {
4603     {"LoadTrackIntoRam", (PyCFunction)TrackObj_LoadTrackIntoRam, 1,
4604      PyDoc_STR("(TimeValue time, TimeValue duration, long flags) -> None")},
4605     {"GetTrackPict", (PyCFunction)TrackObj_GetTrackPict, 1,
4606      PyDoc_STR("(TimeValue time) -> (PicHandle _rv)")},
4607     {"GetTrackClipRgn", (PyCFunction)TrackObj_GetTrackClipRgn, 1,
4608      PyDoc_STR("() -> (RgnHandle _rv)")},
4609     {"SetTrackClipRgn", (PyCFunction)TrackObj_SetTrackClipRgn, 1,
4610      PyDoc_STR("(RgnHandle theClip) -> None")},
4611     {"GetTrackDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackDisplayBoundsRgn, 1,
4612      PyDoc_STR("() -> (RgnHandle _rv)")},
4613     {"GetTrackMovieBoundsRgn", (PyCFunction)TrackObj_GetTrackMovieBoundsRgn, 1,
4614      PyDoc_STR("() -> (RgnHandle _rv)")},
4615     {"GetTrackBoundsRgn", (PyCFunction)TrackObj_GetTrackBoundsRgn, 1,
4616      PyDoc_STR("() -> (RgnHandle _rv)")},
4617     {"GetTrackMatte", (PyCFunction)TrackObj_GetTrackMatte, 1,
4618      PyDoc_STR("() -> (PixMapHandle _rv)")},
4619     {"SetTrackMatte", (PyCFunction)TrackObj_SetTrackMatte, 1,
4620      PyDoc_STR("(PixMapHandle theMatte) -> None")},
4621     {"GetTrackID", (PyCFunction)TrackObj_GetTrackID, 1,
4622      PyDoc_STR("() -> (long _rv)")},
4623     {"GetTrackMovie", (PyCFunction)TrackObj_GetTrackMovie, 1,
4624      PyDoc_STR("() -> (Movie _rv)")},
4625     {"GetTrackCreationTime", (PyCFunction)TrackObj_GetTrackCreationTime, 1,
4626      PyDoc_STR("() -> (unsigned long _rv)")},
4627     {"GetTrackModificationTime", (PyCFunction)TrackObj_GetTrackModificationTime, 1,
4628      PyDoc_STR("() -> (unsigned long _rv)")},
4629     {"GetTrackEnabled", (PyCFunction)TrackObj_GetTrackEnabled, 1,
4630      PyDoc_STR("() -> (Boolean _rv)")},
4631     {"SetTrackEnabled", (PyCFunction)TrackObj_SetTrackEnabled, 1,
4632      PyDoc_STR("(Boolean isEnabled) -> None")},
4633     {"GetTrackUsage", (PyCFunction)TrackObj_GetTrackUsage, 1,
4634      PyDoc_STR("() -> (long _rv)")},
4635     {"SetTrackUsage", (PyCFunction)TrackObj_SetTrackUsage, 1,
4636      PyDoc_STR("(long usage) -> None")},
4637     {"GetTrackDuration", (PyCFunction)TrackObj_GetTrackDuration, 1,
4638      PyDoc_STR("() -> (TimeValue _rv)")},
4639     {"GetTrackOffset", (PyCFunction)TrackObj_GetTrackOffset, 1,
4640      PyDoc_STR("() -> (TimeValue _rv)")},
4641     {"SetTrackOffset", (PyCFunction)TrackObj_SetTrackOffset, 1,
4642      PyDoc_STR("(TimeValue movieOffsetTime) -> None")},
4643     {"GetTrackLayer", (PyCFunction)TrackObj_GetTrackLayer, 1,
4644      PyDoc_STR("() -> (short _rv)")},
4645     {"SetTrackLayer", (PyCFunction)TrackObj_SetTrackLayer, 1,
4646      PyDoc_STR("(short layer) -> None")},
4647     {"GetTrackAlternate", (PyCFunction)TrackObj_GetTrackAlternate, 1,
4648      PyDoc_STR("() -> (Track _rv)")},
4649     {"SetTrackAlternate", (PyCFunction)TrackObj_SetTrackAlternate, 1,
4650      PyDoc_STR("(Track alternateT) -> None")},
4651     {"GetTrackVolume", (PyCFunction)TrackObj_GetTrackVolume, 1,
4652      PyDoc_STR("() -> (short _rv)")},
4653     {"SetTrackVolume", (PyCFunction)TrackObj_SetTrackVolume, 1,
4654      PyDoc_STR("(short volume) -> None")},
4655     {"GetTrackDimensions", (PyCFunction)TrackObj_GetTrackDimensions, 1,
4656      PyDoc_STR("() -> (Fixed width, Fixed height)")},
4657     {"SetTrackDimensions", (PyCFunction)TrackObj_SetTrackDimensions, 1,
4658      PyDoc_STR("(Fixed width, Fixed height) -> None")},
4659     {"GetTrackUserData", (PyCFunction)TrackObj_GetTrackUserData, 1,
4660      PyDoc_STR("() -> (UserData _rv)")},
4661     {"GetTrackSoundLocalizationSettings", (PyCFunction)TrackObj_GetTrackSoundLocalizationSettings, 1,
4662      PyDoc_STR("() -> (Handle settings)")},
4663     {"SetTrackSoundLocalizationSettings", (PyCFunction)TrackObj_SetTrackSoundLocalizationSettings, 1,
4664      PyDoc_STR("(Handle settings) -> None")},
4665     {"NewTrackMedia", (PyCFunction)TrackObj_NewTrackMedia, 1,
4666      PyDoc_STR("(OSType mediaType, TimeScale timeScale, Handle dataRef, OSType dataRefType) -> (Media _rv)")},
4667     {"GetTrackMedia", (PyCFunction)TrackObj_GetTrackMedia, 1,
4668      PyDoc_STR("() -> (Media _rv)")},
4669     {"InsertMediaIntoTrack", (PyCFunction)TrackObj_InsertMediaIntoTrack, 1,
4670      PyDoc_STR("(TimeValue trackStart, TimeValue mediaTime, TimeValue mediaDuration, Fixed mediaRate) -> None")},
4671     {"InsertTrackSegment", (PyCFunction)TrackObj_InsertTrackSegment, 1,
4672      PyDoc_STR("(Track dstTrack, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None")},
4673     {"InsertEmptyTrackSegment", (PyCFunction)TrackObj_InsertEmptyTrackSegment, 1,
4674      PyDoc_STR("(TimeValue dstIn, TimeValue dstDuration) -> None")},
4675     {"DeleteTrackSegment", (PyCFunction)TrackObj_DeleteTrackSegment, 1,
4676      PyDoc_STR("(TimeValue startTime, TimeValue duration) -> None")},
4677     {"ScaleTrackSegment", (PyCFunction)TrackObj_ScaleTrackSegment, 1,
4678      PyDoc_STR("(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None")},
4679     {"IsScrapMovie", (PyCFunction)TrackObj_IsScrapMovie, 1,
4680      PyDoc_STR("() -> (Component _rv)")},
4681     {"CopyTrackSettings", (PyCFunction)TrackObj_CopyTrackSettings, 1,
4682      PyDoc_STR("(Track dstTrack) -> None")},
4683     {"AddEmptyTrackToMovie", (PyCFunction)TrackObj_AddEmptyTrackToMovie, 1,
4684      PyDoc_STR("(Movie dstMovie, Handle dataRef, OSType dataRefType) -> (Track dstTrack)")},
4685     {"AddClonedTrackToMovie", (PyCFunction)TrackObj_AddClonedTrackToMovie, 1,
4686      PyDoc_STR("(Movie dstMovie, long flags) -> (Track dstTrack)")},
4687     {"AddTrackReference", (PyCFunction)TrackObj_AddTrackReference, 1,
4688      PyDoc_STR("(Track refTrack, OSType refType) -> (long addedIndex)")},
4689     {"DeleteTrackReference", (PyCFunction)TrackObj_DeleteTrackReference, 1,
4690      PyDoc_STR("(OSType refType, long index) -> None")},
4691     {"SetTrackReference", (PyCFunction)TrackObj_SetTrackReference, 1,
4692      PyDoc_STR("(Track refTrack, OSType refType, long index) -> None")},
4693     {"GetTrackReference", (PyCFunction)TrackObj_GetTrackReference, 1,
4694      PyDoc_STR("(OSType refType, long index) -> (Track _rv)")},
4695     {"GetNextTrackReferenceType", (PyCFunction)TrackObj_GetNextTrackReferenceType, 1,
4696      PyDoc_STR("(OSType refType) -> (OSType _rv)")},
4697     {"GetTrackReferenceCount", (PyCFunction)TrackObj_GetTrackReferenceCount, 1,
4698      PyDoc_STR("(OSType refType) -> (long _rv)")},
4699     {"GetTrackEditRate", (PyCFunction)TrackObj_GetTrackEditRate, 1,
4700      PyDoc_STR("(TimeValue atTime) -> (Fixed _rv)")},
4701     {"GetTrackDataSize", (PyCFunction)TrackObj_GetTrackDataSize, 1,
4702      PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (long _rv)")},
4703     {"GetTrackDataSize64", (PyCFunction)TrackObj_GetTrackDataSize64, 1,
4704      PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (wide dataSize)")},
4705     {"PtInTrack", (PyCFunction)TrackObj_PtInTrack, 1,
4706      PyDoc_STR("(Point pt) -> (Boolean _rv)")},
4707     {"CopyTrackUserData", (PyCFunction)TrackObj_CopyTrackUserData, 1,
4708      PyDoc_STR("(Track dstTrack, OSType copyRule) -> None")},
4709     {"GetTrackNextInterestingTime", (PyCFunction)TrackObj_GetTrackNextInterestingTime, 1,
4710      PyDoc_STR("(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)")},
4711     {"GetTrackSegmentDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackSegmentDisplayBoundsRgn, 1,
4712      PyDoc_STR("(TimeValue time, TimeValue duration) -> (RgnHandle _rv)")},
4713     {"GetTrackStatus", (PyCFunction)TrackObj_GetTrackStatus, 1,
4714      PyDoc_STR("() -> (ComponentResult _rv)")},
4715     {"SetTrackLoadSettings", (PyCFunction)TrackObj_SetTrackLoadSettings, 1,
4716      PyDoc_STR("(TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints) -> None")},
4717     {"GetTrackLoadSettings", (PyCFunction)TrackObj_GetTrackLoadSettings, 1,
4718      PyDoc_STR("() -> (TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints)")},
4719     {NULL, NULL, 0}
4720 };
4721
4722 #define TrackObj_getsetlist NULL
4723
4724
4725 #define TrackObj_compare NULL
4726
4727 #define TrackObj_repr NULL
4728
4729 #define TrackObj_hash NULL
4730 #define TrackObj_tp_init 0
4731
4732 #define TrackObj_tp_alloc PyType_GenericAlloc
4733
4734 static PyObject *TrackObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
4735 {
4736     PyObject *_self;
4737     Track itself;
4738     char *kw[] = {"itself", 0};
4739
4740     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, TrackObj_Convert, &itself)) return NULL;
4741     if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
4742     ((TrackObject *)_self)->ob_itself = itself;
4743     return _self;
4744 }
4745
4746 #define TrackObj_tp_free PyObject_Del
4747
4748
4749 PyTypeObject Track_Type = {
4750     PyObject_HEAD_INIT(NULL)
4751     0, /*ob_size*/
4752     "_Qt.Track", /*tp_name*/
4753     sizeof(TrackObject), /*tp_basicsize*/
4754     0, /*tp_itemsize*/
4755     /* methods */
4756     (destructor) TrackObj_dealloc, /*tp_dealloc*/
4757     0, /*tp_print*/
4758     (getattrfunc)0, /*tp_getattr*/
4759     (setattrfunc)0, /*tp_setattr*/
4760     (cmpfunc) TrackObj_compare, /*tp_compare*/
4761     (reprfunc) TrackObj_repr, /*tp_repr*/
4762     (PyNumberMethods *)0, /* tp_as_number */
4763     (PySequenceMethods *)0, /* tp_as_sequence */
4764     (PyMappingMethods *)0, /* tp_as_mapping */
4765     (hashfunc) TrackObj_hash, /*tp_hash*/
4766     0, /*tp_call*/
4767     0, /*tp_str*/
4768     PyObject_GenericGetAttr, /*tp_getattro*/
4769     PyObject_GenericSetAttr, /*tp_setattro */
4770     0, /*tp_as_buffer*/
4771     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
4772     0, /*tp_doc*/
4773     0, /*tp_traverse*/
4774     0, /*tp_clear*/
4775     0, /*tp_richcompare*/
4776     0, /*tp_weaklistoffset*/
4777     0, /*tp_iter*/
4778     0, /*tp_iternext*/
4779     TrackObj_methods, /* tp_methods */
4780     0, /*tp_members*/
4781     TrackObj_getsetlist, /*tp_getset*/
4782     0, /*tp_base*/
4783     0, /*tp_dict*/
4784     0, /*tp_descr_get*/
4785     0, /*tp_descr_set*/
4786     0, /*tp_dictoffset*/
4787     TrackObj_tp_init, /* tp_init */
4788     TrackObj_tp_alloc, /* tp_alloc */
4789     TrackObj_tp_new, /* tp_new */
4790     TrackObj_tp_free, /* tp_free */
4791 };
4792
4793 /* --------------------- End object type Track ---------------------- */
4794
4795
4796 /* ----------------------- Object type Movie ------------------------ */
4797
4798 PyTypeObject Movie_Type;
4799
4800 #define MovieObj_Check(x) ((x)->ob_type == &Movie_Type || PyObject_TypeCheck((x), &Movie_Type))
4801
4802 typedef struct MovieObject {
4803     PyObject_HEAD
4804     Movie ob_itself;
4805 } MovieObject;
4806
4807 PyObject *MovieObj_New(Movie itself)
4808 {
4809     MovieObject *it;
4810     if (itself == NULL) {
4811                                     PyErr_SetString(Qt_Error,"Cannot create Movie from NULL pointer");
4812                                     return NULL;
4813                             }
4814     it = PyObject_NEW(MovieObject, &Movie_Type);
4815     if (it == NULL) return NULL;
4816     it->ob_itself = itself;
4817     return (PyObject *)it;
4818 }
4819
4820 int MovieObj_Convert(PyObject *v, Movie *p_itself)
4821 {
4822     if (v == Py_None)
4823     {
4824         *p_itself = NULL;
4825         return 1;
4826     }
4827     if (!MovieObj_Check(v))
4828     {
4829         PyErr_SetString(PyExc_TypeError, "Movie required");
4830         return 0;
4831     }
4832     *p_itself = ((MovieObject *)v)->ob_itself;
4833     return 1;
4834 }
4835
4836 static void MovieObj_dealloc(MovieObject *self)
4837 {
4838     if (self->ob_itself) DisposeMovie(self->ob_itself);
4839     self->ob_type->tp_free((PyObject *)self);
4840 }
4841
4842 static PyObject *MovieObj_MoviesTask(MovieObject *_self, PyObject *_args)
4843 {
4844     PyObject *_res = NULL;
4845     long maxMilliSecToUse;
4846 #ifndef MoviesTask
4847     PyMac_PRECHECK(MoviesTask);
4848 #endif
4849     if (!PyArg_ParseTuple(_args, "l",
4850                           &maxMilliSecToUse))
4851         return NULL;
4852     MoviesTask(_self->ob_itself,
4853                maxMilliSecToUse);
4854     Py_INCREF(Py_None);
4855     _res = Py_None;
4856     return _res;
4857 }
4858
4859 static PyObject *MovieObj_PrerollMovie(MovieObject *_self, PyObject *_args)
4860 {
4861     PyObject *_res = NULL;
4862     OSErr _err;
4863     TimeValue time;
4864     Fixed Rate;
4865 #ifndef PrerollMovie
4866     PyMac_PRECHECK(PrerollMovie);
4867 #endif
4868     if (!PyArg_ParseTuple(_args, "lO&",
4869                           &time,
4870                           PyMac_GetFixed, &Rate))
4871         return NULL;
4872     _err = PrerollMovie(_self->ob_itself,
4873                         time,
4874                         Rate);
4875     if (_err != noErr) return PyMac_Error(_err);
4876     Py_INCREF(Py_None);
4877     _res = Py_None;
4878     return _res;
4879 }
4880
4881 static PyObject *MovieObj_AbortPrePrerollMovie(MovieObject *_self, PyObject *_args)
4882 {
4883     PyObject *_res = NULL;
4884     OSErr err;
4885 #ifndef AbortPrePrerollMovie
4886     PyMac_PRECHECK(AbortPrePrerollMovie);
4887 #endif
4888     if (!PyArg_ParseTuple(_args, "h",
4889                           &err))
4890         return NULL;
4891     AbortPrePrerollMovie(_self->ob_itself,
4892                          err);
4893     Py_INCREF(Py_None);
4894     _res = Py_None;
4895     return _res;
4896 }
4897
4898 static PyObject *MovieObj_LoadMovieIntoRam(MovieObject *_self, PyObject *_args)
4899 {
4900     PyObject *_res = NULL;
4901     OSErr _err;
4902     TimeValue time;
4903     TimeValue duration;
4904     long flags;
4905 #ifndef LoadMovieIntoRam
4906     PyMac_PRECHECK(LoadMovieIntoRam);
4907 #endif
4908     if (!PyArg_ParseTuple(_args, "lll",
4909                           &time,
4910                           &duration,
4911                           &flags))
4912         return NULL;
4913     _err = LoadMovieIntoRam(_self->ob_itself,
4914                             time,
4915                             duration,
4916                             flags);
4917     if (_err != noErr) return PyMac_Error(_err);
4918     Py_INCREF(Py_None);
4919     _res = Py_None;
4920     return _res;
4921 }
4922
4923 static PyObject *MovieObj_SetMovieActive(MovieObject *_self, PyObject *_args)
4924 {
4925     PyObject *_res = NULL;
4926     Boolean active;
4927 #ifndef SetMovieActive
4928     PyMac_PRECHECK(SetMovieActive);
4929 #endif
4930     if (!PyArg_ParseTuple(_args, "b",
4931                           &active))
4932         return NULL;
4933     SetMovieActive(_self->ob_itself,
4934                    active);
4935     Py_INCREF(Py_None);
4936     _res = Py_None;
4937     return _res;
4938 }
4939
4940 static PyObject *MovieObj_GetMovieActive(MovieObject *_self, PyObject *_args)
4941 {
4942     PyObject *_res = NULL;
4943     Boolean _rv;
4944 #ifndef GetMovieActive
4945     PyMac_PRECHECK(GetMovieActive);
4946 #endif
4947     if (!PyArg_ParseTuple(_args, ""))
4948         return NULL;
4949     _rv = GetMovieActive(_self->ob_itself);
4950     _res = Py_BuildValue("b",
4951                          _rv);
4952     return _res;
4953 }
4954
4955 static PyObject *MovieObj_StartMovie(MovieObject *_self, PyObject *_args)
4956 {
4957     PyObject *_res = NULL;
4958 #ifndef StartMovie
4959     PyMac_PRECHECK(StartMovie);
4960 #endif
4961     if (!PyArg_ParseTuple(_args, ""))
4962         return NULL;
4963     StartMovie(_self->ob_itself);
4964     Py_INCREF(Py_None);
4965     _res = Py_None;
4966     return _res;
4967 }
4968
4969 static PyObject *MovieObj_StopMovie(MovieObject *_self, PyObject *_args)
4970 {
4971     PyObject *_res = NULL;
4972 #ifndef StopMovie
4973     PyMac_PRECHECK(StopMovie);
4974 #endif
4975     if (!PyArg_ParseTuple(_args, ""))
4976         return NULL;
4977     StopMovie(_self->ob_itself);
4978     Py_INCREF(Py_None);
4979     _res = Py_None;
4980     return _res;
4981 }
4982
4983 static PyObject *MovieObj_GoToBeginningOfMovie(MovieObject *_self, PyObject *_args)
4984 {
4985     PyObject *_res = NULL;
4986 #ifndef GoToBeginningOfMovie
4987     PyMac_PRECHECK(GoToBeginningOfMovie);
4988 #endif
4989     if (!PyArg_ParseTuple(_args, ""))
4990         return NULL;
4991     GoToBeginningOfMovie(_self->ob_itself);
4992     Py_INCREF(Py_None);
4993     _res = Py_None;
4994     return _res;
4995 }
4996
4997 static PyObject *MovieObj_GoToEndOfMovie(MovieObject *_self, PyObject *_args)
4998 {
4999     PyObject *_res = NULL;
5000 #ifndef GoToEndOfMovie
5001     PyMac_PRECHECK(GoToEndOfMovie);
5002 #endif
5003     if (!PyArg_ParseTuple(_args, ""))
5004         return NULL;
5005     GoToEndOfMovie(_self->ob_itself);
5006     Py_INCREF(Py_None);
5007     _res = Py_None;
5008     return _res;
5009 }
5010
5011 static PyObject *MovieObj_IsMovieDone(MovieObject *_self, PyObject *_args)
5012 {
5013     PyObject *_res = NULL;
5014     Boolean _rv;
5015 #ifndef IsMovieDone
5016     PyMac_PRECHECK(IsMovieDone);
5017 #endif
5018     if (!PyArg_ParseTuple(_args, ""))
5019         return NULL;
5020     _rv = IsMovieDone(_self->ob_itself);
5021     _res = Py_BuildValue("b",
5022                          _rv);
5023     return _res;
5024 }
5025
5026 static PyObject *MovieObj_GetMoviePreviewMode(MovieObject *_self, PyObject *_args)
5027 {
5028     PyObject *_res = NULL;
5029     Boolean _rv;
5030 #ifndef GetMoviePreviewMode
5031     PyMac_PRECHECK(GetMoviePreviewMode);
5032 #endif
5033     if (!PyArg_ParseTuple(_args, ""))
5034         return NULL;
5035     _rv = GetMoviePreviewMode(_self->ob_itself);
5036     _res = Py_BuildValue("b",
5037                          _rv);
5038     return _res;
5039 }
5040
5041 static PyObject *MovieObj_SetMoviePreviewMode(MovieObject *_self, PyObject *_args)
5042 {
5043     PyObject *_res = NULL;
5044     Boolean usePreview;
5045 #ifndef SetMoviePreviewMode
5046     PyMac_PRECHECK(SetMoviePreviewMode);
5047 #endif
5048     if (!PyArg_ParseTuple(_args, "b",
5049                           &usePreview))
5050         return NULL;
5051     SetMoviePreviewMode(_self->ob_itself,
5052                         usePreview);
5053     Py_INCREF(Py_None);
5054     _res = Py_None;
5055     return _res;
5056 }
5057
5058 static PyObject *MovieObj_ShowMoviePoster(MovieObject *_self, PyObject *_args)
5059 {
5060     PyObject *_res = NULL;
5061 #ifndef ShowMoviePoster
5062     PyMac_PRECHECK(ShowMoviePoster);
5063 #endif
5064     if (!PyArg_ParseTuple(_args, ""))
5065         return NULL;
5066     ShowMoviePoster(_self->ob_itself);
5067     Py_INCREF(Py_None);
5068     _res = Py_None;
5069     return _res;
5070 }
5071
5072 static PyObject *MovieObj_GetMovieTimeBase(MovieObject *_self, PyObject *_args)
5073 {
5074     PyObject *_res = NULL;
5075     TimeBase _rv;
5076 #ifndef GetMovieTimeBase
5077     PyMac_PRECHECK(GetMovieTimeBase);
5078 #endif
5079     if (!PyArg_ParseTuple(_args, ""))
5080         return NULL;
5081     _rv = GetMovieTimeBase(_self->ob_itself);
5082     _res = Py_BuildValue("O&",
5083                          TimeBaseObj_New, _rv);
5084     return _res;
5085 }
5086
5087 static PyObject *MovieObj_SetMovieMasterTimeBase(MovieObject *_self, PyObject *_args)
5088 {
5089     PyObject *_res = NULL;
5090     TimeBase tb;
5091     TimeRecord slaveZero;
5092 #ifndef SetMovieMasterTimeBase
5093     PyMac_PRECHECK(SetMovieMasterTimeBase);
5094 #endif
5095     if (!PyArg_ParseTuple(_args, "O&O&",
5096                           TimeBaseObj_Convert, &tb,
5097                           QtTimeRecord_Convert, &slaveZero))
5098         return NULL;
5099     SetMovieMasterTimeBase(_self->ob_itself,
5100                            tb,
5101                            &slaveZero);
5102     Py_INCREF(Py_None);
5103     _res = Py_None;
5104     return _res;
5105 }
5106
5107 static PyObject *MovieObj_SetMovieMasterClock(MovieObject *_self, PyObject *_args)
5108 {
5109     PyObject *_res = NULL;
5110     Component clockMeister;
5111     TimeRecord slaveZero;
5112 #ifndef SetMovieMasterClock
5113     PyMac_PRECHECK(SetMovieMasterClock);
5114 #endif
5115     if (!PyArg_ParseTuple(_args, "O&O&",
5116                           CmpObj_Convert, &clockMeister,
5117                           QtTimeRecord_Convert, &slaveZero))
5118         return NULL;
5119     SetMovieMasterClock(_self->ob_itself,
5120                         clockMeister,
5121                         &slaveZero);
5122     Py_INCREF(Py_None);
5123     _res = Py_None;
5124     return _res;
5125 }
5126
5127 static PyObject *MovieObj_ChooseMovieClock(MovieObject *_self, PyObject *_args)
5128 {
5129     PyObject *_res = NULL;
5130     long flags;
5131 #ifndef ChooseMovieClock
5132     PyMac_PRECHECK(ChooseMovieClock);
5133 #endif
5134     if (!PyArg_ParseTuple(_args, "l",
5135                           &flags))
5136         return NULL;
5137     ChooseMovieClock(_self->ob_itself,
5138                      flags);
5139     Py_INCREF(Py_None);
5140     _res = Py_None;
5141     return _res;
5142 }
5143
5144 static PyObject *MovieObj_GetMovieGWorld(MovieObject *_self, PyObject *_args)
5145 {
5146     PyObject *_res = NULL;
5147     CGrafPtr port;
5148     GDHandle gdh;
5149 #ifndef GetMovieGWorld
5150     PyMac_PRECHECK(GetMovieGWorld);
5151 #endif
5152     if (!PyArg_ParseTuple(_args, ""))
5153         return NULL;
5154     GetMovieGWorld(_self->ob_itself,
5155                    &port,
5156                    &gdh);
5157     _res = Py_BuildValue("O&O&",
5158                          GrafObj_New, port,
5159                          OptResObj_New, gdh);
5160     return _res;
5161 }
5162
5163 static PyObject *MovieObj_SetMovieGWorld(MovieObject *_self, PyObject *_args)
5164 {
5165     PyObject *_res = NULL;
5166     CGrafPtr port;
5167     GDHandle gdh;
5168 #ifndef SetMovieGWorld
5169     PyMac_PRECHECK(SetMovieGWorld);
5170 #endif
5171     if (!PyArg_ParseTuple(_args, "O&O&",
5172                           GrafObj_Convert, &port,
5173                           OptResObj_Convert, &gdh))
5174         return NULL;
5175     SetMovieGWorld(_self->ob_itself,
5176                    port,
5177                    gdh);
5178     Py_INCREF(Py_None);
5179     _res = Py_None;
5180     return _res;
5181 }
5182
5183 static PyObject *MovieObj_GetMovieNaturalBoundsRect(MovieObject *_self, PyObject *_args)
5184 {
5185     PyObject *_res = NULL;
5186     Rect naturalBounds;
5187 #ifndef GetMovieNaturalBoundsRect
5188     PyMac_PRECHECK(GetMovieNaturalBoundsRect);
5189 #endif
5190     if (!PyArg_ParseTuple(_args, ""))
5191         return NULL;
5192     GetMovieNaturalBoundsRect(_self->ob_itself,
5193                               &naturalBounds);
5194     _res = Py_BuildValue("O&",
5195                          PyMac_BuildRect, &naturalBounds);
5196     return _res;
5197 }
5198
5199 static PyObject *MovieObj_GetNextTrackForCompositing(MovieObject *_self, PyObject *_args)
5200 {
5201     PyObject *_res = NULL;
5202     Track _rv;
5203     Track theTrack;
5204 #ifndef GetNextTrackForCompositing
5205     PyMac_PRECHECK(GetNextTrackForCompositing);
5206 #endif
5207     if (!PyArg_ParseTuple(_args, "O&",
5208                           TrackObj_Convert, &theTrack))
5209         return NULL;
5210     _rv = GetNextTrackForCompositing(_self->ob_itself,
5211                                      theTrack);
5212     _res = Py_BuildValue("O&",
5213                          TrackObj_New, _rv);
5214     return _res;
5215 }
5216
5217 static PyObject *MovieObj_GetPrevTrackForCompositing(MovieObject *_self, PyObject *_args)
5218 {
5219     PyObject *_res = NULL;
5220     Track _rv;
5221     Track theTrack;
5222 #ifndef GetPrevTrackForCompositing
5223     PyMac_PRECHECK(GetPrevTrackForCompositing);
5224 #endif
5225     if (!PyArg_ParseTuple(_args, "O&",
5226                           TrackObj_Convert, &theTrack))
5227         return NULL;
5228     _rv = GetPrevTrackForCompositing(_self->ob_itself,
5229                                      theTrack);
5230     _res = Py_BuildValue("O&",
5231                          TrackObj_New, _rv);
5232     return _res;
5233 }
5234
5235 static PyObject *MovieObj_GetMoviePict(MovieObject *_self, PyObject *_args)
5236 {
5237     PyObject *_res = NULL;
5238     PicHandle _rv;
5239     TimeValue time;
5240 #ifndef GetMoviePict
5241     PyMac_PRECHECK(GetMoviePict);
5242 #endif
5243     if (!PyArg_ParseTuple(_args, "l",
5244                           &time))
5245         return NULL;
5246     _rv = GetMoviePict(_self->ob_itself,
5247                        time);
5248     _res = Py_BuildValue("O&",
5249                          ResObj_New, _rv);
5250     return _res;
5251 }
5252
5253 static PyObject *MovieObj_GetMoviePosterPict(MovieObject *_self, PyObject *_args)
5254 {
5255     PyObject *_res = NULL;
5256     PicHandle _rv;
5257 #ifndef GetMoviePosterPict
5258     PyMac_PRECHECK(GetMoviePosterPict);
5259 #endif
5260     if (!PyArg_ParseTuple(_args, ""))
5261         return NULL;
5262     _rv = GetMoviePosterPict(_self->ob_itself);
5263     _res = Py_BuildValue("O&",
5264                          ResObj_New, _rv);
5265     return _res;
5266 }
5267
5268 static PyObject *MovieObj_UpdateMovie(MovieObject *_self, PyObject *_args)
5269 {
5270     PyObject *_res = NULL;
5271     OSErr _err;
5272 #ifndef UpdateMovie
5273     PyMac_PRECHECK(UpdateMovie);
5274 #endif
5275     if (!PyArg_ParseTuple(_args, ""))
5276         return NULL;
5277     _err = UpdateMovie(_self->ob_itself);
5278     if (_err != noErr) return PyMac_Error(_err);
5279     Py_INCREF(Py_None);
5280     _res = Py_None;
5281     return _res;
5282 }
5283
5284 static PyObject *MovieObj_InvalidateMovieRegion(MovieObject *_self, PyObject *_args)
5285 {
5286     PyObject *_res = NULL;
5287     OSErr _err;
5288     RgnHandle invalidRgn;
5289 #ifndef InvalidateMovieRegion
5290     PyMac_PRECHECK(InvalidateMovieRegion);
5291 #endif
5292     if (!PyArg_ParseTuple(_args, "O&",
5293                           ResObj_Convert, &invalidRgn))
5294         return NULL;
5295     _err = InvalidateMovieRegion(_self->ob_itself,
5296                                  invalidRgn);
5297     if (_err != noErr) return PyMac_Error(_err);
5298     Py_INCREF(Py_None);
5299     _res = Py_None;
5300     return _res;
5301 }
5302
5303 static PyObject *MovieObj_GetMovieBox(MovieObject *_self, PyObject *_args)
5304 {
5305     PyObject *_res = NULL;
5306     Rect boxRect;
5307 #ifndef GetMovieBox
5308     PyMac_PRECHECK(GetMovieBox);
5309 #endif
5310     if (!PyArg_ParseTuple(_args, ""))
5311         return NULL;
5312     GetMovieBox(_self->ob_itself,
5313                 &boxRect);
5314     _res = Py_BuildValue("O&",
5315                          PyMac_BuildRect, &boxRect);
5316     return _res;
5317 }
5318
5319 static PyObject *MovieObj_SetMovieBox(MovieObject *_self, PyObject *_args)
5320 {
5321     PyObject *_res = NULL;
5322     Rect boxRect;
5323 #ifndef SetMovieBox
5324     PyMac_PRECHECK(SetMovieBox);
5325 #endif
5326     if (!PyArg_ParseTuple(_args, "O&",
5327                           PyMac_GetRect, &boxRect))
5328         return NULL;
5329     SetMovieBox(_self->ob_itself,
5330                 &boxRect);
5331     Py_INCREF(Py_None);
5332     _res = Py_None;
5333     return _res;
5334 }
5335
5336 static PyObject *MovieObj_GetMovieDisplayClipRgn(MovieObject *_self, PyObject *_args)
5337 {
5338     PyObject *_res = NULL;
5339     RgnHandle _rv;
5340 #ifndef GetMovieDisplayClipRgn
5341     PyMac_PRECHECK(GetMovieDisplayClipRgn);
5342 #endif
5343     if (!PyArg_ParseTuple(_args, ""))
5344         return NULL;
5345     _rv = GetMovieDisplayClipRgn(_self->ob_itself);
5346     _res = Py_BuildValue("O&",
5347                          ResObj_New, _rv);
5348     return _res;
5349 }
5350
5351 static PyObject *MovieObj_SetMovieDisplayClipRgn(MovieObject *_self, PyObject *_args)
5352 {
5353     PyObject *_res = NULL;
5354     RgnHandle theClip;
5355 #ifndef SetMovieDisplayClipRgn
5356     PyMac_PRECHECK(SetMovieDisplayClipRgn);
5357 #endif
5358     if (!PyArg_ParseTuple(_args, "O&",
5359                           ResObj_Convert, &theClip))
5360         return NULL;
5361     SetMovieDisplayClipRgn(_self->ob_itself,
5362                            theClip);
5363     Py_INCREF(Py_None);
5364     _res = Py_None;
5365     return _res;
5366 }
5367
5368 static PyObject *MovieObj_GetMovieClipRgn(MovieObject *_self, PyObject *_args)
5369 {
5370     PyObject *_res = NULL;
5371     RgnHandle _rv;
5372 #ifndef GetMovieClipRgn
5373     PyMac_PRECHECK(GetMovieClipRgn);
5374 #endif
5375     if (!PyArg_ParseTuple(_args, ""))
5376         return NULL;
5377     _rv = GetMovieClipRgn(_self->ob_itself);
5378     _res = Py_BuildValue("O&",
5379                          ResObj_New, _rv);
5380     return _res;
5381 }
5382
5383 static PyObject *MovieObj_SetMovieClipRgn(MovieObject *_self, PyObject *_args)
5384 {
5385     PyObject *_res = NULL;
5386     RgnHandle theClip;
5387 #ifndef SetMovieClipRgn
5388     PyMac_PRECHECK(SetMovieClipRgn);
5389 #endif
5390     if (!PyArg_ParseTuple(_args, "O&",
5391                           ResObj_Convert, &theClip))
5392         return NULL;
5393     SetMovieClipRgn(_self->ob_itself,
5394                     theClip);
5395     Py_INCREF(Py_None);
5396     _res = Py_None;
5397     return _res;
5398 }
5399
5400 static PyObject *MovieObj_GetMovieDisplayBoundsRgn(MovieObject *_self, PyObject *_args)
5401 {
5402     PyObject *_res = NULL;
5403     RgnHandle _rv;
5404 #ifndef GetMovieDisplayBoundsRgn
5405     PyMac_PRECHECK(GetMovieDisplayBoundsRgn);
5406 #endif
5407     if (!PyArg_ParseTuple(_args, ""))
5408         return NULL;
5409     _rv = GetMovieDisplayBoundsRgn(_self->ob_itself);
5410     _res = Py_BuildValue("O&",
5411                          ResObj_New, _rv);
5412     return _res;
5413 }
5414
5415 static PyObject *MovieObj_GetMovieBoundsRgn(MovieObject *_self, PyObject *_args)
5416 {
5417     PyObject *_res = NULL;
5418     RgnHandle _rv;
5419 #ifndef GetMovieBoundsRgn
5420     PyMac_PRECHECK(GetMovieBoundsRgn);
5421 #endif
5422     if (!PyArg_ParseTuple(_args, ""))
5423         return NULL;
5424     _rv = GetMovieBoundsRgn(_self->ob_itself);
5425     _res = Py_BuildValue("O&",
5426                          ResObj_New, _rv);
5427     return _res;
5428 }
5429
5430 static PyObject *MovieObj_SetMovieVideoOutput(MovieObject *_self, PyObject *_args)
5431 {
5432     PyObject *_res = NULL;
5433     ComponentInstance vout;
5434 #ifndef SetMovieVideoOutput
5435     PyMac_PRECHECK(SetMovieVideoOutput);
5436 #endif
5437     if (!PyArg_ParseTuple(_args, "O&",
5438                           CmpInstObj_Convert, &vout))
5439         return NULL;
5440     SetMovieVideoOutput(_self->ob_itself,
5441                         vout);
5442     Py_INCREF(Py_None);
5443     _res = Py_None;
5444     return _res;
5445 }
5446
5447 static PyObject *MovieObj_PutMovieIntoHandle(MovieObject *_self, PyObject *_args)
5448 {
5449     PyObject *_res = NULL;
5450     OSErr _err;
5451     Handle publicMovie;
5452 #ifndef PutMovieIntoHandle
5453     PyMac_PRECHECK(PutMovieIntoHandle);
5454 #endif
5455     if (!PyArg_ParseTuple(_args, "O&",
5456                           ResObj_Convert, &publicMovie))
5457         return NULL;
5458     _err = PutMovieIntoHandle(_self->ob_itself,
5459                               publicMovie);
5460     if (_err != noErr) return PyMac_Error(_err);
5461     Py_INCREF(Py_None);
5462     _res = Py_None;
5463     return _res;
5464 }
5465
5466 static PyObject *MovieObj_PutMovieIntoDataFork(MovieObject *_self, PyObject *_args)
5467 {
5468     PyObject *_res = NULL;
5469     OSErr _err;
5470     short fRefNum;
5471     long offset;
5472     long maxSize;
5473 #ifndef PutMovieIntoDataFork
5474     PyMac_PRECHECK(PutMovieIntoDataFork);
5475 #endif
5476     if (!PyArg_ParseTuple(_args, "hll",
5477                           &fRefNum,
5478                           &offset,
5479                           &maxSize))
5480         return NULL;
5481     _err = PutMovieIntoDataFork(_self->ob_itself,
5482                                 fRefNum,
5483                                 offset,
5484                                 maxSize);
5485     if (_err != noErr) return PyMac_Error(_err);
5486     Py_INCREF(Py_None);
5487     _res = Py_None;
5488     return _res;
5489 }
5490
5491 static PyObject *MovieObj_PutMovieIntoDataFork64(MovieObject *_self, PyObject *_args)
5492 {
5493     PyObject *_res = NULL;
5494     OSErr _err;
5495     long fRefNum;
5496     wide offset;
5497     unsigned long maxSize;
5498 #ifndef PutMovieIntoDataFork64
5499     PyMac_PRECHECK(PutMovieIntoDataFork64);
5500 #endif
5501     if (!PyArg_ParseTuple(_args, "lO&l",
5502                           &fRefNum,
5503                           PyMac_Getwide, &offset,
5504                           &maxSize))
5505         return NULL;
5506     _err = PutMovieIntoDataFork64(_self->ob_itself,
5507                                   fRefNum,
5508                                   &offset,
5509                                   maxSize);
5510     if (_err != noErr) return PyMac_Error(_err);
5511     Py_INCREF(Py_None);
5512     _res = Py_None;
5513     return _res;
5514 }
5515
5516 static PyObject *MovieObj_PutMovieIntoStorage(MovieObject *_self, PyObject *_args)
5517 {
5518     PyObject *_res = NULL;
5519     OSErr _err;
5520     DataHandler dh;
5521     wide offset;
5522     unsigned long maxSize;
5523 #ifndef PutMovieIntoStorage
5524     PyMac_PRECHECK(PutMovieIntoStorage);
5525 #endif
5526     if (!PyArg_ParseTuple(_args, "O&O&l",
5527                           CmpInstObj_Convert, &dh,
5528                           PyMac_Getwide, &offset,
5529                           &maxSize))
5530         return NULL;
5531     _err = PutMovieIntoStorage(_self->ob_itself,
5532                                dh,
5533                                &offset,
5534                                maxSize);
5535     if (_err != noErr) return PyMac_Error(_err);
5536     Py_INCREF(Py_None);
5537     _res = Py_None;
5538     return _res;
5539 }
5540
5541 static PyObject *MovieObj_PutMovieForDataRefIntoHandle(MovieObject *_self, PyObject *_args)
5542 {
5543     PyObject *_res = NULL;
5544     OSErr _err;
5545     Handle dataRef;
5546     OSType dataRefType;
5547     Handle publicMovie;
5548 #ifndef PutMovieForDataRefIntoHandle
5549     PyMac_PRECHECK(PutMovieForDataRefIntoHandle);
5550 #endif
5551     if (!PyArg_ParseTuple(_args, "O&O&O&",
5552                           ResObj_Convert, &dataRef,
5553                           PyMac_GetOSType, &dataRefType,
5554                           ResObj_Convert, &publicMovie))
5555         return NULL;
5556     _err = PutMovieForDataRefIntoHandle(_self->ob_itself,
5557                                         dataRef,
5558                                         dataRefType,
5559                                         publicMovie);
5560     if (_err != noErr) return PyMac_Error(_err);
5561     Py_INCREF(Py_None);
5562     _res = Py_None;
5563     return _res;
5564 }
5565
5566 static PyObject *MovieObj_GetMovieCreationTime(MovieObject *_self, PyObject *_args)
5567 {
5568     PyObject *_res = NULL;
5569     unsigned long _rv;
5570 #ifndef GetMovieCreationTime
5571     PyMac_PRECHECK(GetMovieCreationTime);
5572 #endif
5573     if (!PyArg_ParseTuple(_args, ""))
5574         return NULL;
5575     _rv = GetMovieCreationTime(_self->ob_itself);
5576     _res = Py_BuildValue("l",
5577                          _rv);
5578     return _res;
5579 }
5580
5581 static PyObject *MovieObj_GetMovieModificationTime(MovieObject *_self, PyObject *_args)
5582 {
5583     PyObject *_res = NULL;
5584     unsigned long _rv;
5585 #ifndef GetMovieModificationTime
5586     PyMac_PRECHECK(GetMovieModificationTime);
5587 #endif
5588     if (!PyArg_ParseTuple(_args, ""))
5589         return NULL;
5590     _rv = GetMovieModificationTime(_self->ob_itself);
5591     _res = Py_BuildValue("l",
5592                          _rv);
5593     return _res;
5594 }
5595
5596 static PyObject *MovieObj_GetMovieTimeScale(MovieObject *_self, PyObject *_args)
5597 {
5598     PyObject *_res = NULL;
5599     TimeScale _rv;
5600 #ifndef GetMovieTimeScale
5601     PyMac_PRECHECK(GetMovieTimeScale);
5602 #endif
5603     if (!PyArg_ParseTuple(_args, ""))
5604         return NULL;
5605     _rv = GetMovieTimeScale(_self->ob_itself);
5606     _res = Py_BuildValue("l",
5607                          _rv);
5608     return _res;
5609 }
5610
5611 static PyObject *MovieObj_SetMovieTimeScale(MovieObject *_self, PyObject *_args)
5612 {
5613     PyObject *_res = NULL;
5614     TimeScale timeScale;
5615 #ifndef SetMovieTimeScale
5616     PyMac_PRECHECK(SetMovieTimeScale);
5617 #endif
5618     if (!PyArg_ParseTuple(_args, "l",
5619                           &timeScale))
5620         return NULL;
5621     SetMovieTimeScale(_self->ob_itself,
5622                       timeScale);
5623     Py_INCREF(Py_None);
5624     _res = Py_None;
5625     return _res;
5626 }
5627
5628 static PyObject *MovieObj_GetMovieDuration(MovieObject *_self, PyObject *_args)
5629 {
5630     PyObject *_res = NULL;
5631     TimeValue _rv;
5632 #ifndef GetMovieDuration
5633     PyMac_PRECHECK(GetMovieDuration);
5634 #endif
5635     if (!PyArg_ParseTuple(_args, ""))
5636         return NULL;
5637     _rv = GetMovieDuration(_self->ob_itself);
5638     _res = Py_BuildValue("l",
5639                          _rv);
5640     return _res;
5641 }
5642
5643 static PyObject *MovieObj_GetMovieRate(MovieObject *_self, PyObject *_args)
5644 {
5645     PyObject *_res = NULL;
5646     Fixed _rv;
5647 #ifndef GetMovieRate
5648     PyMac_PRECHECK(GetMovieRate);
5649 #endif
5650     if (!PyArg_ParseTuple(_args, ""))
5651         return NULL;
5652     _rv = GetMovieRate(_self->ob_itself);
5653     _res = Py_BuildValue("O&",
5654                          PyMac_BuildFixed, _rv);
5655     return _res;
5656 }
5657
5658 static PyObject *MovieObj_SetMovieRate(MovieObject *_self, PyObject *_args)
5659 {
5660     PyObject *_res = NULL;
5661     Fixed rate;
5662 #ifndef SetMovieRate
5663     PyMac_PRECHECK(SetMovieRate);
5664 #endif
5665     if (!PyArg_ParseTuple(_args, "O&",
5666                           PyMac_GetFixed, &rate))
5667         return NULL;
5668     SetMovieRate(_self->ob_itself,
5669                  rate);
5670     Py_INCREF(Py_None);
5671     _res = Py_None;
5672     return _res;
5673 }
5674
5675 static PyObject *MovieObj_GetMoviePreferredRate(MovieObject *_self, PyObject *_args)
5676 {
5677     PyObject *_res = NULL;
5678     Fixed _rv;
5679 #ifndef GetMoviePreferredRate
5680     PyMac_PRECHECK(GetMoviePreferredRate);
5681 #endif
5682     if (!PyArg_ParseTuple(_args, ""))
5683         return NULL;
5684     _rv = GetMoviePreferredRate(_self->ob_itself);
5685     _res = Py_BuildValue("O&",
5686                          PyMac_BuildFixed, _rv);
5687     return _res;
5688 }
5689
5690 static PyObject *MovieObj_SetMoviePreferredRate(MovieObject *_self, PyObject *_args)
5691 {
5692     PyObject *_res = NULL;
5693     Fixed rate;
5694 #ifndef SetMoviePreferredRate
5695     PyMac_PRECHECK(SetMoviePreferredRate);
5696 #endif
5697     if (!PyArg_ParseTuple(_args, "O&",
5698                           PyMac_GetFixed, &rate))
5699         return NULL;
5700     SetMoviePreferredRate(_self->ob_itself,
5701                           rate);
5702     Py_INCREF(Py_None);
5703     _res = Py_None;
5704     return _res;
5705 }
5706
5707 static PyObject *MovieObj_GetMoviePreferredVolume(MovieObject *_self, PyObject *_args)
5708 {
5709     PyObject *_res = NULL;
5710     short _rv;
5711 #ifndef GetMoviePreferredVolume
5712     PyMac_PRECHECK(GetMoviePreferredVolume);
5713 #endif
5714     if (!PyArg_ParseTuple(_args, ""))
5715         return NULL;
5716     _rv = GetMoviePreferredVolume(_self->ob_itself);
5717     _res = Py_BuildValue("h",
5718                          _rv);
5719     return _res;
5720 }
5721
5722 static PyObject *MovieObj_SetMoviePreferredVolume(MovieObject *_self, PyObject *_args)
5723 {
5724     PyObject *_res = NULL;
5725     short volume;
5726 #ifndef SetMoviePreferredVolume
5727     PyMac_PRECHECK(SetMoviePreferredVolume);
5728 #endif
5729     if (!PyArg_ParseTuple(_args, "h",
5730                           &volume))
5731         return NULL;
5732     SetMoviePreferredVolume(_self->ob_itself,
5733                             volume);
5734     Py_INCREF(Py_None);
5735     _res = Py_None;
5736     return _res;
5737 }
5738
5739 static PyObject *MovieObj_GetMovieVolume(MovieObject *_self, PyObject *_args)
5740 {
5741     PyObject *_res = NULL;
5742     short _rv;
5743 #ifndef GetMovieVolume
5744     PyMac_PRECHECK(GetMovieVolume);
5745 #endif
5746     if (!PyArg_ParseTuple(_args, ""))
5747         return NULL;
5748     _rv = GetMovieVolume(_self->ob_itself);
5749     _res = Py_BuildValue("h",
5750                          _rv);
5751     return _res;
5752 }
5753
5754 static PyObject *MovieObj_SetMovieVolume(MovieObject *_self, PyObject *_args)
5755 {
5756     PyObject *_res = NULL;
5757     short volume;
5758 #ifndef SetMovieVolume
5759     PyMac_PRECHECK(SetMovieVolume);
5760 #endif
5761     if (!PyArg_ParseTuple(_args, "h",
5762                           &volume))
5763         return NULL;
5764     SetMovieVolume(_self->ob_itself,
5765                    volume);
5766     Py_INCREF(Py_None);
5767     _res = Py_None;
5768     return _res;
5769 }
5770
5771 static PyObject *MovieObj_GetMoviePreviewTime(MovieObject *_self, PyObject *_args)
5772 {
5773     PyObject *_res = NULL;
5774     TimeValue previewTime;
5775     TimeValue previewDuration;
5776 #ifndef GetMoviePreviewTime
5777     PyMac_PRECHECK(GetMoviePreviewTime);
5778 #endif
5779     if (!PyArg_ParseTuple(_args, ""))
5780         return NULL;
5781     GetMoviePreviewTime(_self->ob_itself,
5782                         &previewTime,
5783                         &previewDuration);
5784     _res = Py_BuildValue("ll",
5785                          previewTime,
5786                          previewDuration);
5787     return _res;
5788 }
5789
5790 static PyObject *MovieObj_SetMoviePreviewTime(MovieObject *_self, PyObject *_args)
5791 {
5792     PyObject *_res = NULL;
5793     TimeValue previewTime;
5794     TimeValue previewDuration;
5795 #ifndef SetMoviePreviewTime
5796     PyMac_PRECHECK(SetMoviePreviewTime);
5797 #endif
5798     if (!PyArg_ParseTuple(_args, "ll",
5799                           &previewTime,
5800                           &previewDuration))
5801         return NULL;
5802     SetMoviePreviewTime(_self->ob_itself,
5803                         previewTime,
5804                         previewDuration);
5805     Py_INCREF(Py_None);
5806     _res = Py_None;
5807     return _res;
5808 }
5809
5810 static PyObject *MovieObj_GetMoviePosterTime(MovieObject *_self, PyObject *_args)
5811 {
5812     PyObject *_res = NULL;
5813     TimeValue _rv;
5814 #ifndef GetMoviePosterTime
5815     PyMac_PRECHECK(GetMoviePosterTime);
5816 #endif
5817     if (!PyArg_ParseTuple(_args, ""))
5818         return NULL;
5819     _rv = GetMoviePosterTime(_self->ob_itself);
5820     _res = Py_BuildValue("l",
5821                          _rv);
5822     return _res;
5823 }
5824
5825 static PyObject *MovieObj_SetMoviePosterTime(MovieObject *_self, PyObject *_args)
5826 {
5827     PyObject *_res = NULL;
5828     TimeValue posterTime;
5829 #ifndef SetMoviePosterTime
5830     PyMac_PRECHECK(SetMoviePosterTime);
5831 #endif
5832     if (!PyArg_ParseTuple(_args, "l",
5833                           &posterTime))
5834         return NULL;
5835     SetMoviePosterTime(_self->ob_itself,
5836                        posterTime);
5837     Py_INCREF(Py_None);
5838     _res = Py_None;
5839     return _res;
5840 }
5841
5842 static PyObject *MovieObj_GetMovieSelection(MovieObject *_self, PyObject *_args)
5843 {
5844     PyObject *_res = NULL;
5845     TimeValue selectionTime;
5846     TimeValue selectionDuration;
5847 #ifndef GetMovieSelection
5848     PyMac_PRECHECK(GetMovieSelection);
5849 #endif
5850     if (!PyArg_ParseTuple(_args, ""))
5851         return NULL;
5852     GetMovieSelection(_self->ob_itself,
5853                       &selectionTime,
5854                       &selectionDuration);
5855     _res = Py_BuildValue("ll",
5856                          selectionTime,
5857                          selectionDuration);
5858     return _res;
5859 }
5860
5861 static PyObject *MovieObj_SetMovieSelection(MovieObject *_self, PyObject *_args)
5862 {
5863     PyObject *_res = NULL;
5864     TimeValue selectionTime;
5865     TimeValue selectionDuration;
5866 #ifndef SetMovieSelection
5867     PyMac_PRECHECK(SetMovieSelection);
5868 #endif
5869     if (!PyArg_ParseTuple(_args, "ll",
5870                           &selectionTime,
5871                           &selectionDuration))
5872         return NULL;
5873     SetMovieSelection(_self->ob_itself,
5874                       selectionTime,
5875                       selectionDuration);
5876     Py_INCREF(Py_None);
5877     _res = Py_None;
5878     return _res;
5879 }
5880
5881 static PyObject *MovieObj_SetMovieActiveSegment(MovieObject *_self, PyObject *_args)
5882 {
5883     PyObject *_res = NULL;
5884     TimeValue startTime;
5885     TimeValue duration;
5886 #ifndef SetMovieActiveSegment
5887     PyMac_PRECHECK(SetMovieActiveSegment);
5888 #endif
5889     if (!PyArg_ParseTuple(_args, "ll",
5890                           &startTime,
5891                           &duration))
5892         return NULL;
5893     SetMovieActiveSegment(_self->ob_itself,
5894                           startTime,
5895                           duration);
5896     Py_INCREF(Py_None);
5897     _res = Py_None;
5898     return _res;
5899 }
5900
5901 static PyObject *MovieObj_GetMovieActiveSegment(MovieObject *_self, PyObject *_args)
5902 {
5903     PyObject *_res = NULL;
5904     TimeValue startTime;
5905     TimeValue duration;
5906 #ifndef GetMovieActiveSegment
5907     PyMac_PRECHECK(GetMovieActiveSegment);
5908 #endif
5909     if (!PyArg_ParseTuple(_args, ""))
5910         return NULL;
5911     GetMovieActiveSegment(_self->ob_itself,
5912                           &startTime,
5913                           &duration);
5914     _res = Py_BuildValue("ll",
5915                          startTime,
5916                          duration);
5917     return _res;
5918 }
5919
5920 static PyObject *MovieObj_GetMovieTime(MovieObject *_self, PyObject *_args)
5921 {
5922     PyObject *_res = NULL;
5923     TimeValue _rv;
5924     TimeRecord currentTime;
5925 #ifndef GetMovieTime
5926     PyMac_PRECHECK(GetMovieTime);
5927 #endif
5928     if (!PyArg_ParseTuple(_args, ""))
5929         return NULL;
5930     _rv = GetMovieTime(_self->ob_itself,
5931                        &currentTime);
5932     _res = Py_BuildValue("lO&",
5933                          _rv,
5934                          QtTimeRecord_New, &currentTime);
5935     return _res;
5936 }
5937
5938 static PyObject *MovieObj_SetMovieTime(MovieObject *_self, PyObject *_args)
5939 {
5940     PyObject *_res = NULL;
5941     TimeRecord newtime;
5942 #ifndef SetMovieTime
5943     PyMac_PRECHECK(SetMovieTime);
5944 #endif
5945     if (!PyArg_ParseTuple(_args, "O&",
5946                           QtTimeRecord_Convert, &newtime))
5947         return NULL;
5948     SetMovieTime(_self->ob_itself,
5949                  &newtime);
5950     Py_INCREF(Py_None);
5951     _res = Py_None;
5952     return _res;
5953 }
5954
5955 static PyObject *MovieObj_SetMovieTimeValue(MovieObject *_self, PyObject *_args)
5956 {
5957     PyObject *_res = NULL;
5958     TimeValue newtime;
5959 #ifndef SetMovieTimeValue
5960     PyMac_PRECHECK(SetMovieTimeValue);
5961 #endif
5962     if (!PyArg_ParseTuple(_args, "l",
5963                           &newtime))
5964         return NULL;
5965     SetMovieTimeValue(_self->ob_itself,
5966                       newtime);
5967     Py_INCREF(Py_None);
5968     _res = Py_None;
5969     return _res;
5970 }
5971
5972 static PyObject *MovieObj_GetMovieUserData(MovieObject *_self, PyObject *_args)
5973 {
5974     PyObject *_res = NULL;
5975     UserData _rv;
5976 #ifndef GetMovieUserData
5977     PyMac_PRECHECK(GetMovieUserData);
5978 #endif
5979     if (!PyArg_ParseTuple(_args, ""))
5980         return NULL;
5981     _rv = GetMovieUserData(_self->ob_itself);
5982     _res = Py_BuildValue("O&",
5983                          UserDataObj_New, _rv);
5984     return _res;
5985 }
5986
5987 static PyObject *MovieObj_GetMovieTrackCount(MovieObject *_self, PyObject *_args)
5988 {
5989     PyObject *_res = NULL;
5990     long _rv;
5991 #ifndef GetMovieTrackCount
5992     PyMac_PRECHECK(GetMovieTrackCount);
5993 #endif
5994     if (!PyArg_ParseTuple(_args, ""))
5995         return NULL;
5996     _rv = GetMovieTrackCount(_self->ob_itself);
5997     _res = Py_BuildValue("l",
5998                          _rv);
5999     return _res;
6000 }
6001
6002 static PyObject *MovieObj_GetMovieTrack(MovieObject *_self, PyObject *_args)
6003 {
6004     PyObject *_res = NULL;
6005     Track _rv;
6006     long trackID;
6007 #ifndef GetMovieTrack
6008     PyMac_PRECHECK(GetMovieTrack);
6009 #endif
6010     if (!PyArg_ParseTuple(_args, "l",
6011                           &trackID))
6012         return NULL;
6013     _rv = GetMovieTrack(_self->ob_itself,
6014                         trackID);
6015     _res = Py_BuildValue("O&",
6016                          TrackObj_New, _rv);
6017     return _res;
6018 }
6019
6020 static PyObject *MovieObj_GetMovieIndTrack(MovieObject *_self, PyObject *_args)
6021 {
6022     PyObject *_res = NULL;
6023     Track _rv;
6024     long index;
6025 #ifndef GetMovieIndTrack
6026     PyMac_PRECHECK(GetMovieIndTrack);
6027 #endif
6028     if (!PyArg_ParseTuple(_args, "l",
6029                           &index))
6030         return NULL;
6031     _rv = GetMovieIndTrack(_self->ob_itself,
6032                            index);
6033     _res = Py_BuildValue("O&",
6034                          TrackObj_New, _rv);
6035     return _res;
6036 }
6037
6038 static PyObject *MovieObj_GetMovieIndTrackType(MovieObject *_self, PyObject *_args)
6039 {
6040     PyObject *_res = NULL;
6041     Track _rv;
6042     long index;
6043     OSType trackType;
6044     long flags;
6045 #ifndef GetMovieIndTrackType
6046     PyMac_PRECHECK(GetMovieIndTrackType);
6047 #endif
6048     if (!PyArg_ParseTuple(_args, "lO&l",
6049                           &index,
6050                           PyMac_GetOSType, &trackType,
6051                           &flags))
6052         return NULL;
6053     _rv = GetMovieIndTrackType(_self->ob_itself,
6054                                index,
6055                                trackType,
6056                                flags);
6057     _res = Py_BuildValue("O&",
6058                          TrackObj_New, _rv);
6059     return _res;
6060 }
6061
6062 static PyObject *MovieObj_NewMovieTrack(MovieObject *_self, PyObject *_args)
6063 {
6064     PyObject *_res = NULL;
6065     Track _rv;
6066     Fixed width;
6067     Fixed height;
6068     short trackVolume;
6069 #ifndef NewMovieTrack
6070     PyMac_PRECHECK(NewMovieTrack);
6071 #endif
6072     if (!PyArg_ParseTuple(_args, "O&O&h",
6073                           PyMac_GetFixed, &width,
6074                           PyMac_GetFixed, &height,
6075                           &trackVolume))
6076         return NULL;
6077     _rv = NewMovieTrack(_self->ob_itself,
6078                         width,
6079                         height,
6080                         trackVolume);
6081     _res = Py_BuildValue("O&",
6082                          TrackObj_New, _rv);
6083     return _res;
6084 }
6085
6086 static PyObject *MovieObj_SetAutoTrackAlternatesEnabled(MovieObject *_self, PyObject *_args)
6087 {
6088     PyObject *_res = NULL;
6089     Boolean enable;
6090 #ifndef SetAutoTrackAlternatesEnabled
6091     PyMac_PRECHECK(SetAutoTrackAlternatesEnabled);
6092 #endif
6093     if (!PyArg_ParseTuple(_args, "b",
6094                           &enable))
6095         return NULL;
6096     SetAutoTrackAlternatesEnabled(_self->ob_itself,
6097                                   enable);
6098     Py_INCREF(Py_None);
6099     _res = Py_None;
6100     return _res;
6101 }
6102
6103 static PyObject *MovieObj_SelectMovieAlternates(MovieObject *_self, PyObject *_args)
6104 {
6105     PyObject *_res = NULL;
6106 #ifndef SelectMovieAlternates
6107     PyMac_PRECHECK(SelectMovieAlternates);
6108 #endif
6109     if (!PyArg_ParseTuple(_args, ""))
6110         return NULL;
6111     SelectMovieAlternates(_self->ob_itself);
6112     Py_INCREF(Py_None);
6113     _res = Py_None;
6114     return _res;
6115 }
6116
6117 static PyObject *MovieObj_InsertMovieSegment(MovieObject *_self, PyObject *_args)
6118 {
6119     PyObject *_res = NULL;
6120     OSErr _err;
6121     Movie dstMovie;
6122     TimeValue srcIn;
6123     TimeValue srcDuration;
6124     TimeValue dstIn;
6125 #ifndef InsertMovieSegment
6126     PyMac_PRECHECK(InsertMovieSegment);
6127 #endif
6128     if (!PyArg_ParseTuple(_args, "O&lll",
6129                           MovieObj_Convert, &dstMovie,
6130                           &srcIn,
6131                           &srcDuration,
6132                           &dstIn))
6133         return NULL;
6134     _err = InsertMovieSegment(_self->ob_itself,
6135                               dstMovie,
6136                               srcIn,
6137                               srcDuration,
6138                               dstIn);
6139     if (_err != noErr) return PyMac_Error(_err);
6140     Py_INCREF(Py_None);
6141     _res = Py_None;
6142     return _res;
6143 }
6144
6145 static PyObject *MovieObj_InsertEmptyMovieSegment(MovieObject *_self, PyObject *_args)
6146 {
6147     PyObject *_res = NULL;
6148     OSErr _err;
6149     TimeValue dstIn;
6150     TimeValue dstDuration;
6151 #ifndef InsertEmptyMovieSegment
6152     PyMac_PRECHECK(InsertEmptyMovieSegment);
6153 #endif
6154     if (!PyArg_ParseTuple(_args, "ll",
6155                           &dstIn,
6156                           &dstDuration))
6157         return NULL;
6158     _err = InsertEmptyMovieSegment(_self->ob_itself,
6159                                    dstIn,
6160                                    dstDuration);
6161     if (_err != noErr) return PyMac_Error(_err);
6162     Py_INCREF(Py_None);
6163     _res = Py_None;
6164     return _res;
6165 }
6166
6167 static PyObject *MovieObj_DeleteMovieSegment(MovieObject *_self, PyObject *_args)
6168 {
6169     PyObject *_res = NULL;
6170     OSErr _err;
6171     TimeValue startTime;
6172     TimeValue duration;
6173 #ifndef DeleteMovieSegment
6174     PyMac_PRECHECK(DeleteMovieSegment);
6175 #endif
6176     if (!PyArg_ParseTuple(_args, "ll",
6177                           &startTime,
6178                           &duration))
6179         return NULL;
6180     _err = DeleteMovieSegment(_self->ob_itself,
6181                               startTime,
6182                               duration);
6183     if (_err != noErr) return PyMac_Error(_err);
6184     Py_INCREF(Py_None);
6185     _res = Py_None;
6186     return _res;
6187 }
6188
6189 static PyObject *MovieObj_ScaleMovieSegment(MovieObject *_self, PyObject *_args)
6190 {
6191     PyObject *_res = NULL;
6192     OSErr _err;
6193     TimeValue startTime;
6194     TimeValue oldDuration;
6195     TimeValue newDuration;
6196 #ifndef ScaleMovieSegment
6197     PyMac_PRECHECK(ScaleMovieSegment);
6198 #endif
6199     if (!PyArg_ParseTuple(_args, "lll",
6200                           &startTime,
6201                           &oldDuration,
6202                           &newDuration))
6203         return NULL;
6204     _err = ScaleMovieSegment(_self->ob_itself,
6205                              startTime,
6206                              oldDuration,
6207                              newDuration);
6208     if (_err != noErr) return PyMac_Error(_err);
6209     Py_INCREF(Py_None);
6210     _res = Py_None;
6211     return _res;
6212 }
6213
6214 static PyObject *MovieObj_CutMovieSelection(MovieObject *_self, PyObject *_args)
6215 {
6216     PyObject *_res = NULL;
6217     Movie _rv;
6218 #ifndef CutMovieSelection
6219     PyMac_PRECHECK(CutMovieSelection);
6220 #endif
6221     if (!PyArg_ParseTuple(_args, ""))
6222         return NULL;
6223     _rv = CutMovieSelection(_self->ob_itself);
6224     _res = Py_BuildValue("O&",
6225                          MovieObj_New, _rv);
6226     return _res;
6227 }
6228
6229 static PyObject *MovieObj_CopyMovieSelection(MovieObject *_self, PyObject *_args)
6230 {
6231     PyObject *_res = NULL;
6232     Movie _rv;
6233 #ifndef CopyMovieSelection
6234     PyMac_PRECHECK(CopyMovieSelection);
6235 #endif
6236     if (!PyArg_ParseTuple(_args, ""))
6237         return NULL;
6238     _rv = CopyMovieSelection(_self->ob_itself);
6239     _res = Py_BuildValue("O&",
6240                          MovieObj_New, _rv);
6241     return _res;
6242 }
6243
6244 static PyObject *MovieObj_PasteMovieSelection(MovieObject *_self, PyObject *_args)
6245 {
6246     PyObject *_res = NULL;
6247     Movie src;
6248 #ifndef PasteMovieSelection
6249     PyMac_PRECHECK(PasteMovieSelection);
6250 #endif
6251     if (!PyArg_ParseTuple(_args, "O&",
6252                           MovieObj_Convert, &src))
6253         return NULL;
6254     PasteMovieSelection(_self->ob_itself,
6255                         src);
6256     Py_INCREF(Py_None);
6257     _res = Py_None;
6258     return _res;
6259 }
6260
6261 static PyObject *MovieObj_AddMovieSelection(MovieObject *_self, PyObject *_args)
6262 {
6263     PyObject *_res = NULL;
6264     Movie src;
6265 #ifndef AddMovieSelection
6266     PyMac_PRECHECK(AddMovieSelection);
6267 #endif
6268     if (!PyArg_ParseTuple(_args, "O&",
6269                           MovieObj_Convert, &src))
6270         return NULL;
6271     AddMovieSelection(_self->ob_itself,
6272                       src);
6273     Py_INCREF(Py_None);
6274     _res = Py_None;
6275     return _res;
6276 }
6277
6278 static PyObject *MovieObj_ClearMovieSelection(MovieObject *_self, PyObject *_args)
6279 {
6280     PyObject *_res = NULL;
6281 #ifndef ClearMovieSelection
6282     PyMac_PRECHECK(ClearMovieSelection);
6283 #endif
6284     if (!PyArg_ParseTuple(_args, ""))
6285         return NULL;
6286     ClearMovieSelection(_self->ob_itself);
6287     Py_INCREF(Py_None);
6288     _res = Py_None;
6289     return _res;
6290 }
6291
6292 static PyObject *MovieObj_PutMovieIntoTypedHandle(MovieObject *_self, PyObject *_args)
6293 {
6294     PyObject *_res = NULL;
6295     OSErr _err;
6296     Track targetTrack;
6297     OSType handleType;
6298     Handle publicMovie;
6299     TimeValue start;
6300     TimeValue dur;
6301     long flags;
6302     ComponentInstance userComp;
6303 #ifndef PutMovieIntoTypedHandle
6304     PyMac_PRECHECK(PutMovieIntoTypedHandle);
6305 #endif
6306     if (!PyArg_ParseTuple(_args, "O&O&O&lllO&",
6307                           TrackObj_Convert, &targetTrack,
6308                           PyMac_GetOSType, &handleType,
6309                           ResObj_Convert, &publicMovie,
6310                           &start,
6311                           &dur,
6312                           &flags,
6313                           CmpInstObj_Convert, &userComp))
6314         return NULL;
6315     _err = PutMovieIntoTypedHandle(_self->ob_itself,
6316                                    targetTrack,
6317                                    handleType,
6318                                    publicMovie,
6319                                    start,
6320                                    dur,
6321                                    flags,
6322                                    userComp);
6323     if (_err != noErr) return PyMac_Error(_err);
6324     Py_INCREF(Py_None);
6325     _res = Py_None;
6326     return _res;
6327 }
6328
6329 static PyObject *MovieObj_CopyMovieSettings(MovieObject *_self, PyObject *_args)
6330 {
6331     PyObject *_res = NULL;
6332     OSErr _err;
6333     Movie dstMovie;
6334 #ifndef CopyMovieSettings
6335     PyMac_PRECHECK(CopyMovieSettings);
6336 #endif
6337     if (!PyArg_ParseTuple(_args, "O&",
6338                           MovieObj_Convert, &dstMovie))
6339         return NULL;
6340     _err = CopyMovieSettings(_self->ob_itself,
6341                              dstMovie);
6342     if (_err != noErr) return PyMac_Error(_err);
6343     Py_INCREF(Py_None);
6344     _res = Py_None;
6345     return _res;
6346 }
6347
6348 static PyObject *MovieObj_ConvertMovieToFile(MovieObject *_self, PyObject *_args)
6349 {
6350     PyObject *_res = NULL;
6351     OSErr _err;
6352     Track onlyTrack;
6353     FSSpec outputFile;
6354     OSType fileType;
6355     OSType creator;
6356     ScriptCode scriptTag;
6357     short resID;
6358     long flags;
6359     ComponentInstance userComp;
6360 #ifndef ConvertMovieToFile
6361     PyMac_PRECHECK(ConvertMovieToFile);
6362 #endif
6363     if (!PyArg_ParseTuple(_args, "O&O&O&O&hlO&",
6364                           TrackObj_Convert, &onlyTrack,
6365                           PyMac_GetFSSpec, &outputFile,
6366                           PyMac_GetOSType, &fileType,
6367                           PyMac_GetOSType, &creator,
6368                           &scriptTag,
6369                           &flags,
6370                           CmpInstObj_Convert, &userComp))
6371         return NULL;
6372     _err = ConvertMovieToFile(_self->ob_itself,
6373                               onlyTrack,
6374                               &outputFile,
6375                               fileType,
6376                               creator,
6377                               scriptTag,
6378                               &resID,
6379                               flags,
6380                               userComp);
6381     if (_err != noErr) return PyMac_Error(_err);
6382     _res = Py_BuildValue("h",
6383                          resID);
6384     return _res;
6385 }
6386
6387 static PyObject *MovieObj_GetMovieDataSize(MovieObject *_self, PyObject *_args)
6388 {
6389     PyObject *_res = NULL;
6390     long _rv;
6391     TimeValue startTime;
6392     TimeValue duration;
6393 #ifndef GetMovieDataSize
6394     PyMac_PRECHECK(GetMovieDataSize);
6395 #endif
6396     if (!PyArg_ParseTuple(_args, "ll",
6397                           &startTime,
6398                           &duration))
6399         return NULL;
6400     _rv = GetMovieDataSize(_self->ob_itself,
6401                            startTime,
6402                            duration);
6403     _res = Py_BuildValue("l",
6404                          _rv);
6405     return _res;
6406 }
6407
6408 static PyObject *MovieObj_GetMovieDataSize64(MovieObject *_self, PyObject *_args)
6409 {
6410     PyObject *_res = NULL;
6411     OSErr _err;
6412     TimeValue startTime;
6413     TimeValue duration;
6414     wide dataSize;
6415 #ifndef GetMovieDataSize64
6416     PyMac_PRECHECK(GetMovieDataSize64);
6417 #endif
6418     if (!PyArg_ParseTuple(_args, "ll",
6419                           &startTime,
6420                           &duration))
6421         return NULL;
6422     _err = GetMovieDataSize64(_self->ob_itself,
6423                               startTime,
6424                               duration,
6425                               &dataSize);
6426     if (_err != noErr) return PyMac_Error(_err);
6427     _res = Py_BuildValue("O&",
6428                          PyMac_Buildwide, dataSize);
6429     return _res;
6430 }
6431
6432 static PyObject *MovieObj_PtInMovie(MovieObject *_self, PyObject *_args)
6433 {
6434     PyObject *_res = NULL;
6435     Boolean _rv;
6436     Point pt;
6437 #ifndef PtInMovie
6438     PyMac_PRECHECK(PtInMovie);
6439 #endif
6440     if (!PyArg_ParseTuple(_args, "O&",
6441                           PyMac_GetPoint, &pt))
6442         return NULL;
6443     _rv = PtInMovie(_self->ob_itself,
6444                     pt);
6445     _res = Py_BuildValue("b",
6446                          _rv);
6447     return _res;
6448 }
6449
6450 static PyObject *MovieObj_SetMovieLanguage(MovieObject *_self, PyObject *_args)
6451 {
6452     PyObject *_res = NULL;
6453     long language;
6454 #ifndef SetMovieLanguage
6455     PyMac_PRECHECK(SetMovieLanguage);
6456 #endif
6457     if (!PyArg_ParseTuple(_args, "l",
6458                           &language))
6459         return NULL;
6460     SetMovieLanguage(_self->ob_itself,
6461                      language);
6462     Py_INCREF(Py_None);
6463     _res = Py_None;
6464     return _res;
6465 }
6466
6467 static PyObject *MovieObj_CopyMovieUserData(MovieObject *_self, PyObject *_args)
6468 {
6469     PyObject *_res = NULL;
6470     OSErr _err;
6471     Movie dstMovie;
6472     OSType copyRule;
6473 #ifndef CopyMovieUserData
6474     PyMac_PRECHECK(CopyMovieUserData);
6475 #endif
6476     if (!PyArg_ParseTuple(_args, "O&O&",
6477                           MovieObj_Convert, &dstMovie,
6478                           PyMac_GetOSType, &copyRule))
6479         return NULL;
6480     _err = CopyMovieUserData(_self->ob_itself,
6481                              dstMovie,
6482                              copyRule);
6483     if (_err != noErr) return PyMac_Error(_err);
6484     Py_INCREF(Py_None);
6485     _res = Py_None;
6486     return _res;
6487 }
6488
6489 static PyObject *MovieObj_GetMovieNextInterestingTime(MovieObject *_self, PyObject *_args)
6490 {
6491     PyObject *_res = NULL;
6492     short interestingTimeFlags;
6493     short numMediaTypes;
6494     OSType whichMediaTypes;
6495     TimeValue time;
6496     Fixed rate;
6497     TimeValue interestingTime;
6498     TimeValue interestingDuration;
6499 #ifndef GetMovieNextInterestingTime
6500     PyMac_PRECHECK(GetMovieNextInterestingTime);
6501 #endif
6502     if (!PyArg_ParseTuple(_args, "hhO&lO&",
6503                           &interestingTimeFlags,
6504                           &numMediaTypes,
6505                           PyMac_GetOSType, &whichMediaTypes,
6506                           &time,
6507                           PyMac_GetFixed, &rate))
6508         return NULL;
6509     GetMovieNextInterestingTime(_self->ob_itself,
6510                                 interestingTimeFlags,
6511                                 numMediaTypes,
6512                                 &whichMediaTypes,
6513                                 time,
6514                                 rate,
6515                                 &interestingTime,
6516                                 &interestingDuration);
6517     _res = Py_BuildValue("ll",
6518                          interestingTime,
6519                          interestingDuration);
6520     return _res;
6521 }
6522
6523 static PyObject *MovieObj_AddMovieResource(MovieObject *_self, PyObject *_args)
6524 {
6525     PyObject *_res = NULL;
6526     OSErr _err;
6527     short resRefNum;
6528     short resId;
6529     Str255 resName;
6530 #ifndef AddMovieResource
6531     PyMac_PRECHECK(AddMovieResource);
6532 #endif
6533     if (!PyArg_ParseTuple(_args, "hO&",
6534                           &resRefNum,
6535                           PyMac_GetStr255, resName))
6536         return NULL;
6537     _err = AddMovieResource(_self->ob_itself,
6538                             resRefNum,
6539                             &resId,
6540                             resName);
6541     if (_err != noErr) return PyMac_Error(_err);
6542     _res = Py_BuildValue("h",
6543                          resId);
6544     return _res;
6545 }
6546
6547 static PyObject *MovieObj_UpdateMovieResource(MovieObject *_self, PyObject *_args)
6548 {
6549     PyObject *_res = NULL;
6550     OSErr _err;
6551     short resRefNum;
6552     short resId;
6553     Str255 resName;
6554 #ifndef UpdateMovieResource
6555     PyMac_PRECHECK(UpdateMovieResource);
6556 #endif
6557     if (!PyArg_ParseTuple(_args, "hhO&",
6558                           &resRefNum,
6559                           &resId,
6560                           PyMac_GetStr255, resName))
6561         return NULL;
6562     _err = UpdateMovieResource(_self->ob_itself,
6563                                resRefNum,
6564                                resId,
6565                                resName);
6566     if (_err != noErr) return PyMac_Error(_err);
6567     Py_INCREF(Py_None);
6568     _res = Py_None;
6569     return _res;
6570 }
6571
6572 static PyObject *MovieObj_AddMovieToStorage(MovieObject *_self, PyObject *_args)
6573 {
6574     PyObject *_res = NULL;
6575     OSErr _err;
6576     DataHandler dh;
6577 #ifndef AddMovieToStorage
6578     PyMac_PRECHECK(AddMovieToStorage);
6579 #endif
6580     if (!PyArg_ParseTuple(_args, "O&",
6581                           CmpInstObj_Convert, &dh))
6582         return NULL;
6583     _err = AddMovieToStorage(_self->ob_itself,
6584                              dh);
6585     if (_err != noErr) return PyMac_Error(_err);
6586     Py_INCREF(Py_None);
6587     _res = Py_None;
6588     return _res;
6589 }
6590
6591 static PyObject *MovieObj_UpdateMovieInStorage(MovieObject *_self, PyObject *_args)
6592 {
6593     PyObject *_res = NULL;
6594     OSErr _err;
6595     DataHandler dh;
6596 #ifndef UpdateMovieInStorage
6597     PyMac_PRECHECK(UpdateMovieInStorage);
6598 #endif
6599     if (!PyArg_ParseTuple(_args, "O&",
6600                           CmpInstObj_Convert, &dh))
6601         return NULL;
6602     _err = UpdateMovieInStorage(_self->ob_itself,
6603                                 dh);
6604     if (_err != noErr) return PyMac_Error(_err);
6605     Py_INCREF(Py_None);
6606     _res = Py_None;
6607     return _res;
6608 }
6609
6610 static PyObject *MovieObj_HasMovieChanged(MovieObject *_self, PyObject *_args)
6611 {
6612     PyObject *_res = NULL;
6613     Boolean _rv;
6614 #ifndef HasMovieChanged
6615     PyMac_PRECHECK(HasMovieChanged);
6616 #endif
6617     if (!PyArg_ParseTuple(_args, ""))
6618         return NULL;
6619     _rv = HasMovieChanged(_self->ob_itself);
6620     _res = Py_BuildValue("b",
6621                          _rv);
6622     return _res;
6623 }
6624
6625 static PyObject *MovieObj_ClearMovieChanged(MovieObject *_self, PyObject *_args)
6626 {
6627     PyObject *_res = NULL;
6628 #ifndef ClearMovieChanged
6629     PyMac_PRECHECK(ClearMovieChanged);
6630 #endif
6631     if (!PyArg_ParseTuple(_args, ""))
6632         return NULL;
6633     ClearMovieChanged(_self->ob_itself);
6634     Py_INCREF(Py_None);
6635     _res = Py_None;
6636     return _res;
6637 }
6638
6639 static PyObject *MovieObj_SetMovieDefaultDataRef(MovieObject *_self, PyObject *_args)
6640 {
6641     PyObject *_res = NULL;
6642     OSErr _err;
6643     Handle dataRef;
6644     OSType dataRefType;
6645 #ifndef SetMovieDefaultDataRef
6646     PyMac_PRECHECK(SetMovieDefaultDataRef);
6647 #endif
6648     if (!PyArg_ParseTuple(_args, "O&O&",
6649                           ResObj_Convert, &dataRef,
6650                           PyMac_GetOSType, &dataRefType))
6651         return NULL;
6652     _err = SetMovieDefaultDataRef(_self->ob_itself,
6653                                   dataRef,
6654                                   dataRefType);
6655     if (_err != noErr) return PyMac_Error(_err);
6656     Py_INCREF(Py_None);
6657     _res = Py_None;
6658     return _res;
6659 }
6660
6661 static PyObject *MovieObj_GetMovieDefaultDataRef(MovieObject *_self, PyObject *_args)
6662 {
6663     PyObject *_res = NULL;
6664     OSErr _err;
6665     Handle dataRef;
6666     OSType dataRefType;
6667 #ifndef GetMovieDefaultDataRef
6668     PyMac_PRECHECK(GetMovieDefaultDataRef);
6669 #endif
6670     if (!PyArg_ParseTuple(_args, ""))
6671         return NULL;
6672     _err = GetMovieDefaultDataRef(_self->ob_itself,
6673                                   &dataRef,
6674                                   &dataRefType);
6675     if (_err != noErr) return PyMac_Error(_err);
6676     _res = Py_BuildValue("O&O&",
6677                          ResObj_New, dataRef,
6678                          PyMac_BuildOSType, dataRefType);
6679     return _res;
6680 }
6681
6682 static PyObject *MovieObj_SetMovieColorTable(MovieObject *_self, PyObject *_args)
6683 {
6684     PyObject *_res = NULL;
6685     OSErr _err;
6686     CTabHandle ctab;
6687 #ifndef SetMovieColorTable
6688     PyMac_PRECHECK(SetMovieColorTable);
6689 #endif
6690     if (!PyArg_ParseTuple(_args, "O&",
6691                           ResObj_Convert, &ctab))
6692         return NULL;
6693     _err = SetMovieColorTable(_self->ob_itself,
6694                               ctab);
6695     if (_err != noErr) return PyMac_Error(_err);
6696     Py_INCREF(Py_None);
6697     _res = Py_None;
6698     return _res;
6699 }
6700
6701 static PyObject *MovieObj_GetMovieColorTable(MovieObject *_self, PyObject *_args)
6702 {
6703     PyObject *_res = NULL;
6704     OSErr _err;
6705     CTabHandle ctab;
6706 #ifndef GetMovieColorTable
6707     PyMac_PRECHECK(GetMovieColorTable);
6708 #endif
6709     if (!PyArg_ParseTuple(_args, ""))
6710         return NULL;
6711     _err = GetMovieColorTable(_self->ob_itself,
6712                               &ctab);
6713     if (_err != noErr) return PyMac_Error(_err);
6714     _res = Py_BuildValue("O&",
6715                          ResObj_New, ctab);
6716     return _res;
6717 }
6718
6719 static PyObject *MovieObj_FlattenMovie(MovieObject *_self, PyObject *_args)
6720 {
6721     PyObject *_res = NULL;
6722     long movieFlattenFlags;
6723     FSSpec theFile;
6724     OSType creator;
6725     ScriptCode scriptTag;
6726     long createMovieFileFlags;
6727     short resId;
6728     Str255 resName;
6729 #ifndef FlattenMovie
6730     PyMac_PRECHECK(FlattenMovie);
6731 #endif
6732     if (!PyArg_ParseTuple(_args, "lO&O&hlO&",
6733                           &movieFlattenFlags,
6734                           PyMac_GetFSSpec, &theFile,
6735                           PyMac_GetOSType, &creator,
6736                           &scriptTag,
6737                           &createMovieFileFlags,
6738                           PyMac_GetStr255, resName))
6739         return NULL;
6740     FlattenMovie(_self->ob_itself,
6741                  movieFlattenFlags,
6742                  &theFile,
6743                  creator,
6744                  scriptTag,
6745                  createMovieFileFlags,
6746                  &resId,
6747                  resName);
6748     _res = Py_BuildValue("h",
6749                          resId);
6750     return _res;
6751 }
6752
6753 static PyObject *MovieObj_FlattenMovieData(MovieObject *_self, PyObject *_args)
6754 {
6755     PyObject *_res = NULL;
6756     Movie _rv;
6757     long movieFlattenFlags;
6758     FSSpec theFile;
6759     OSType creator;
6760     ScriptCode scriptTag;
6761     long createMovieFileFlags;
6762 #ifndef FlattenMovieData
6763     PyMac_PRECHECK(FlattenMovieData);
6764 #endif
6765     if (!PyArg_ParseTuple(_args, "lO&O&hl",
6766                           &movieFlattenFlags,
6767                           PyMac_GetFSSpec, &theFile,
6768                           PyMac_GetOSType, &creator,
6769                           &scriptTag,
6770                           &createMovieFileFlags))
6771         return NULL;
6772     _rv = FlattenMovieData(_self->ob_itself,
6773                            movieFlattenFlags,
6774                            &theFile,
6775                            creator,
6776                            scriptTag,
6777                            createMovieFileFlags);
6778     _res = Py_BuildValue("O&",
6779                          MovieObj_New, _rv);
6780     return _res;
6781 }
6782
6783 static PyObject *MovieObj_FlattenMovieDataToDataRef(MovieObject *_self, PyObject *_args)
6784 {
6785     PyObject *_res = NULL;
6786     Movie _rv;
6787     long movieFlattenFlags;
6788     Handle dataRef;
6789     OSType dataRefType;
6790     OSType creator;
6791     ScriptCode scriptTag;
6792     long createMovieFileFlags;
6793 #ifndef FlattenMovieDataToDataRef
6794     PyMac_PRECHECK(FlattenMovieDataToDataRef);
6795 #endif
6796     if (!PyArg_ParseTuple(_args, "lO&O&O&hl",
6797                           &movieFlattenFlags,
6798                           ResObj_Convert, &dataRef,
6799                           PyMac_GetOSType, &dataRefType,
6800                           PyMac_GetOSType, &creator,
6801                           &scriptTag,
6802                           &createMovieFileFlags))
6803         return NULL;
6804     _rv = FlattenMovieDataToDataRef(_self->ob_itself,
6805                                     movieFlattenFlags,
6806                                     dataRef,
6807                                     dataRefType,
6808                                     creator,
6809                                     scriptTag,
6810                                     createMovieFileFlags);
6811     _res = Py_BuildValue("O&",
6812                          MovieObj_New, _rv);
6813     return _res;
6814 }
6815
6816 static PyObject *MovieObj_MovieSearchText(MovieObject *_self, PyObject *_args)
6817 {
6818     PyObject *_res = NULL;
6819     OSErr _err;
6820     Ptr text;
6821     long size;
6822     long searchFlags;
6823     Track searchTrack;
6824     TimeValue searchTime;
6825     long searchOffset;
6826 #ifndef MovieSearchText
6827     PyMac_PRECHECK(MovieSearchText);
6828 #endif
6829     if (!PyArg_ParseTuple(_args, "sll",
6830                           &text,
6831                           &size,
6832                           &searchFlags))
6833         return NULL;
6834     _err = MovieSearchText(_self->ob_itself,
6835                            text,
6836                            size,
6837                            searchFlags,
6838                            &searchTrack,
6839                            &searchTime,
6840                            &searchOffset);
6841     if (_err != noErr) return PyMac_Error(_err);
6842     _res = Py_BuildValue("O&ll",
6843                          TrackObj_New, searchTrack,
6844                          searchTime,
6845                          searchOffset);
6846     return _res;
6847 }
6848
6849 static PyObject *MovieObj_GetPosterBox(MovieObject *_self, PyObject *_args)
6850 {
6851     PyObject *_res = NULL;
6852     Rect boxRect;
6853 #ifndef GetPosterBox
6854     PyMac_PRECHECK(GetPosterBox);
6855 #endif
6856     if (!PyArg_ParseTuple(_args, ""))
6857         return NULL;
6858     GetPosterBox(_self->ob_itself,
6859                  &boxRect);
6860     _res = Py_BuildValue("O&",
6861                          PyMac_BuildRect, &boxRect);
6862     return _res;
6863 }
6864
6865 static PyObject *MovieObj_SetPosterBox(MovieObject *_self, PyObject *_args)
6866 {
6867     PyObject *_res = NULL;
6868     Rect boxRect;
6869 #ifndef SetPosterBox
6870     PyMac_PRECHECK(SetPosterBox);
6871 #endif
6872     if (!PyArg_ParseTuple(_args, "O&",
6873                           PyMac_GetRect, &boxRect))
6874         return NULL;
6875     SetPosterBox(_self->ob_itself,
6876                  &boxRect);
6877     Py_INCREF(Py_None);
6878     _res = Py_None;
6879     return _res;
6880 }
6881
6882 static PyObject *MovieObj_GetMovieSegmentDisplayBoundsRgn(MovieObject *_self, PyObject *_args)
6883 {
6884     PyObject *_res = NULL;
6885     RgnHandle _rv;
6886     TimeValue time;
6887     TimeValue duration;
6888 #ifndef GetMovieSegmentDisplayBoundsRgn
6889     PyMac_PRECHECK(GetMovieSegmentDisplayBoundsRgn);
6890 #endif
6891     if (!PyArg_ParseTuple(_args, "ll",
6892                           &time,
6893                           &duration))
6894         return NULL;
6895     _rv = GetMovieSegmentDisplayBoundsRgn(_self->ob_itself,
6896                                           time,
6897                                           duration);
6898     _res = Py_BuildValue("O&",
6899                          ResObj_New, _rv);
6900     return _res;
6901 }
6902
6903 static PyObject *MovieObj_GetMovieStatus(MovieObject *_self, PyObject *_args)
6904 {
6905     PyObject *_res = NULL;
6906     ComponentResult _rv;
6907     Track firstProblemTrack;
6908 #ifndef GetMovieStatus
6909     PyMac_PRECHECK(GetMovieStatus);
6910 #endif
6911     if (!PyArg_ParseTuple(_args, ""))
6912         return NULL;
6913     _rv = GetMovieStatus(_self->ob_itself,
6914                          &firstProblemTrack);
6915     _res = Py_BuildValue("lO&",
6916                          _rv,
6917                          TrackObj_New, firstProblemTrack);
6918     return _res;
6919 }
6920
6921 static PyObject *MovieObj_NewMovieController(MovieObject *_self, PyObject *_args)
6922 {
6923     PyObject *_res = NULL;
6924     MovieController _rv;
6925     Rect movieRect;
6926     long someFlags;
6927 #ifndef NewMovieController
6928     PyMac_PRECHECK(NewMovieController);
6929 #endif
6930     if (!PyArg_ParseTuple(_args, "O&l",
6931                           PyMac_GetRect, &movieRect,
6932                           &someFlags))
6933         return NULL;
6934     _rv = NewMovieController(_self->ob_itself,
6935                              &movieRect,
6936                              someFlags);
6937     _res = Py_BuildValue("O&",
6938                          MovieCtlObj_New, _rv);
6939     return _res;
6940 }
6941
6942 static PyObject *MovieObj_PutMovieOnScrap(MovieObject *_self, PyObject *_args)
6943 {
6944     PyObject *_res = NULL;
6945     OSErr _err;
6946     long movieScrapFlags;
6947 #ifndef PutMovieOnScrap
6948     PyMac_PRECHECK(PutMovieOnScrap);
6949 #endif
6950     if (!PyArg_ParseTuple(_args, "l",
6951                           &movieScrapFlags))
6952         return NULL;
6953     _err = PutMovieOnScrap(_self->ob_itself,
6954                            movieScrapFlags);
6955     if (_err != noErr) return PyMac_Error(_err);
6956     Py_INCREF(Py_None);
6957     _res = Py_None;
6958     return _res;
6959 }
6960
6961 static PyObject *MovieObj_SetMoviePlayHints(MovieObject *_self, PyObject *_args)
6962 {
6963     PyObject *_res = NULL;
6964     long flags;
6965     long flagsMask;
6966 #ifndef SetMoviePlayHints
6967     PyMac_PRECHECK(SetMoviePlayHints);
6968 #endif
6969     if (!PyArg_ParseTuple(_args, "ll",
6970                           &flags,
6971                           &flagsMask))
6972         return NULL;
6973     SetMoviePlayHints(_self->ob_itself,
6974                       flags,
6975                       flagsMask);
6976     Py_INCREF(Py_None);
6977     _res = Py_None;
6978     return _res;
6979 }
6980
6981 static PyObject *MovieObj_GetMaxLoadedTimeInMovie(MovieObject *_self, PyObject *_args)
6982 {
6983     PyObject *_res = NULL;
6984     OSErr _err;
6985     TimeValue time;
6986 #ifndef GetMaxLoadedTimeInMovie
6987     PyMac_PRECHECK(GetMaxLoadedTimeInMovie);
6988 #endif
6989     if (!PyArg_ParseTuple(_args, ""))
6990         return NULL;
6991     _err = GetMaxLoadedTimeInMovie(_self->ob_itself,
6992                                    &time);
6993     if (_err != noErr) return PyMac_Error(_err);
6994     _res = Py_BuildValue("l",
6995                          time);
6996     return _res;
6997 }
6998
6999 static PyObject *MovieObj_QTMovieNeedsTimeTable(MovieObject *_self, PyObject *_args)
7000 {
7001     PyObject *_res = NULL;
7002     OSErr _err;
7003     Boolean needsTimeTable;
7004 #ifndef QTMovieNeedsTimeTable
7005     PyMac_PRECHECK(QTMovieNeedsTimeTable);
7006 #endif
7007     if (!PyArg_ParseTuple(_args, ""))
7008         return NULL;
7009     _err = QTMovieNeedsTimeTable(_self->ob_itself,
7010                                  &needsTimeTable);
7011     if (_err != noErr) return PyMac_Error(_err);
7012     _res = Py_BuildValue("b",
7013                          needsTimeTable);
7014     return _res;
7015 }
7016
7017 static PyObject *MovieObj_QTGetDataRefMaxFileOffset(MovieObject *_self, PyObject *_args)
7018 {
7019     PyObject *_res = NULL;
7020     OSErr _err;
7021     OSType dataRefType;
7022     Handle dataRef;
7023     long offset;
7024 #ifndef QTGetDataRefMaxFileOffset
7025     PyMac_PRECHECK(QTGetDataRefMaxFileOffset);
7026 #endif
7027     if (!PyArg_ParseTuple(_args, "O&O&",
7028                           PyMac_GetOSType, &dataRefType,
7029                           ResObj_Convert, &dataRef))
7030         return NULL;
7031     _err = QTGetDataRefMaxFileOffset(_self->ob_itself,
7032                                      dataRefType,
7033                                      dataRef,
7034                                      &offset);
7035     if (_err != noErr) return PyMac_Error(_err);
7036     _res = Py_BuildValue("l",
7037                          offset);
7038     return _res;
7039 }
7040
7041 static PyMethodDef MovieObj_methods[] = {
7042     {"MoviesTask", (PyCFunction)MovieObj_MoviesTask, 1,
7043      PyDoc_STR("(long maxMilliSecToUse) -> None")},
7044     {"PrerollMovie", (PyCFunction)MovieObj_PrerollMovie, 1,
7045      PyDoc_STR("(TimeValue time, Fixed Rate) -> None")},
7046     {"AbortPrePrerollMovie", (PyCFunction)MovieObj_AbortPrePrerollMovie, 1,
7047      PyDoc_STR("(OSErr err) -> None")},
7048     {"LoadMovieIntoRam", (PyCFunction)MovieObj_LoadMovieIntoRam, 1,
7049      PyDoc_STR("(TimeValue time, TimeValue duration, long flags) -> None")},
7050     {"SetMovieActive", (PyCFunction)MovieObj_SetMovieActive, 1,
7051      PyDoc_STR("(Boolean active) -> None")},
7052     {"GetMovieActive", (PyCFunction)MovieObj_GetMovieActive, 1,
7053      PyDoc_STR("() -> (Boolean _rv)")},
7054     {"StartMovie", (PyCFunction)MovieObj_StartMovie, 1,
7055      PyDoc_STR("() -> None")},
7056     {"StopMovie", (PyCFunction)MovieObj_StopMovie, 1,
7057      PyDoc_STR("() -> None")},
7058     {"GoToBeginningOfMovie", (PyCFunction)MovieObj_GoToBeginningOfMovie, 1,
7059      PyDoc_STR("() -> None")},
7060     {"GoToEndOfMovie", (PyCFunction)MovieObj_GoToEndOfMovie, 1,
7061      PyDoc_STR("() -> None")},
7062     {"IsMovieDone", (PyCFunction)MovieObj_IsMovieDone, 1,
7063      PyDoc_STR("() -> (Boolean _rv)")},
7064     {"GetMoviePreviewMode", (PyCFunction)MovieObj_GetMoviePreviewMode, 1,
7065      PyDoc_STR("() -> (Boolean _rv)")},
7066     {"SetMoviePreviewMode", (PyCFunction)MovieObj_SetMoviePreviewMode, 1,
7067      PyDoc_STR("(Boolean usePreview) -> None")},
7068     {"ShowMoviePoster", (PyCFunction)MovieObj_ShowMoviePoster, 1,
7069      PyDoc_STR("() -> None")},
7070     {"GetMovieTimeBase", (PyCFunction)MovieObj_GetMovieTimeBase, 1,
7071      PyDoc_STR("() -> (TimeBase _rv)")},
7072     {"SetMovieMasterTimeBase", (PyCFunction)MovieObj_SetMovieMasterTimeBase, 1,
7073      PyDoc_STR("(TimeBase tb, TimeRecord slaveZero) -> None")},
7074     {"SetMovieMasterClock", (PyCFunction)MovieObj_SetMovieMasterClock, 1,
7075      PyDoc_STR("(Component clockMeister, TimeRecord slaveZero) -> None")},
7076     {"ChooseMovieClock", (PyCFunction)MovieObj_ChooseMovieClock, 1,
7077      PyDoc_STR("(long flags) -> None")},
7078     {"GetMovieGWorld", (PyCFunction)MovieObj_GetMovieGWorld, 1,
7079      PyDoc_STR("() -> (CGrafPtr port, GDHandle gdh)")},
7080     {"SetMovieGWorld", (PyCFunction)MovieObj_SetMovieGWorld, 1,
7081      PyDoc_STR("(CGrafPtr port, GDHandle gdh) -> None")},
7082     {"GetMovieNaturalBoundsRect", (PyCFunction)MovieObj_GetMovieNaturalBoundsRect, 1,
7083      PyDoc_STR("() -> (Rect naturalBounds)")},
7084     {"GetNextTrackForCompositing", (PyCFunction)MovieObj_GetNextTrackForCompositing, 1,
7085      PyDoc_STR("(Track theTrack) -> (Track _rv)")},
7086     {"GetPrevTrackForCompositing", (PyCFunction)MovieObj_GetPrevTrackForCompositing, 1,
7087      PyDoc_STR("(Track theTrack) -> (Track _rv)")},
7088     {"GetMoviePict", (PyCFunction)MovieObj_GetMoviePict, 1,
7089      PyDoc_STR("(TimeValue time) -> (PicHandle _rv)")},
7090     {"GetMoviePosterPict", (PyCFunction)MovieObj_GetMoviePosterPict, 1,
7091      PyDoc_STR("() -> (PicHandle _rv)")},
7092     {"UpdateMovie", (PyCFunction)MovieObj_UpdateMovie, 1,
7093      PyDoc_STR("() -> None")},
7094     {"InvalidateMovieRegion", (PyCFunction)MovieObj_InvalidateMovieRegion, 1,
7095      PyDoc_STR("(RgnHandle invalidRgn) -> None")},
7096     {"GetMovieBox", (PyCFunction)MovieObj_GetMovieBox, 1,
7097      PyDoc_STR("() -> (Rect boxRect)")},
7098     {"SetMovieBox", (PyCFunction)MovieObj_SetMovieBox, 1,
7099      PyDoc_STR("(Rect boxRect) -> None")},
7100     {"GetMovieDisplayClipRgn", (PyCFunction)MovieObj_GetMovieDisplayClipRgn, 1,
7101      PyDoc_STR("() -> (RgnHandle _rv)")},
7102     {"SetMovieDisplayClipRgn", (PyCFunction)MovieObj_SetMovieDisplayClipRgn, 1,
7103      PyDoc_STR("(RgnHandle theClip) -> None")},
7104     {"GetMovieClipRgn", (PyCFunction)MovieObj_GetMovieClipRgn, 1,
7105      PyDoc_STR("() -> (RgnHandle _rv)")},
7106     {"SetMovieClipRgn", (PyCFunction)MovieObj_SetMovieClipRgn, 1,
7107      PyDoc_STR("(RgnHandle theClip) -> None")},
7108     {"GetMovieDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieDisplayBoundsRgn, 1,
7109      PyDoc_STR("() -> (RgnHandle _rv)")},
7110     {"GetMovieBoundsRgn", (PyCFunction)MovieObj_GetMovieBoundsRgn, 1,
7111      PyDoc_STR("() -> (RgnHandle _rv)")},
7112     {"SetMovieVideoOutput", (PyCFunction)MovieObj_SetMovieVideoOutput, 1,
7113      PyDoc_STR("(ComponentInstance vout) -> None")},
7114     {"PutMovieIntoHandle", (PyCFunction)MovieObj_PutMovieIntoHandle, 1,
7115      PyDoc_STR("(Handle publicMovie) -> None")},
7116     {"PutMovieIntoDataFork", (PyCFunction)MovieObj_PutMovieIntoDataFork, 1,
7117      PyDoc_STR("(short fRefNum, long offset, long maxSize) -> None")},
7118     {"PutMovieIntoDataFork64", (PyCFunction)MovieObj_PutMovieIntoDataFork64, 1,
7119      PyDoc_STR("(long fRefNum, wide offset, unsigned long maxSize) -> None")},
7120     {"PutMovieIntoStorage", (PyCFunction)MovieObj_PutMovieIntoStorage, 1,
7121      PyDoc_STR("(DataHandler dh, wide offset, unsigned long maxSize) -> None")},
7122     {"PutMovieForDataRefIntoHandle", (PyCFunction)MovieObj_PutMovieForDataRefIntoHandle, 1,
7123      PyDoc_STR("(Handle dataRef, OSType dataRefType, Handle publicMovie) -> None")},
7124     {"GetMovieCreationTime", (PyCFunction)MovieObj_GetMovieCreationTime, 1,
7125      PyDoc_STR("() -> (unsigned long _rv)")},
7126     {"GetMovieModificationTime", (PyCFunction)MovieObj_GetMovieModificationTime, 1,
7127      PyDoc_STR("() -> (unsigned long _rv)")},
7128     {"GetMovieTimeScale", (PyCFunction)MovieObj_GetMovieTimeScale, 1,
7129      PyDoc_STR("() -> (TimeScale _rv)")},
7130     {"SetMovieTimeScale", (PyCFunction)MovieObj_SetMovieTimeScale, 1,
7131      PyDoc_STR("(TimeScale timeScale) -> None")},
7132     {"GetMovieDuration", (PyCFunction)MovieObj_GetMovieDuration, 1,
7133      PyDoc_STR("() -> (TimeValue _rv)")},
7134     {"GetMovieRate", (PyCFunction)MovieObj_GetMovieRate, 1,
7135      PyDoc_STR("() -> (Fixed _rv)")},
7136     {"SetMovieRate", (PyCFunction)MovieObj_SetMovieRate, 1,
7137      PyDoc_STR("(Fixed rate) -> None")},
7138     {"GetMoviePreferredRate", (PyCFunction)MovieObj_GetMoviePreferredRate, 1,
7139      PyDoc_STR("() -> (Fixed _rv)")},
7140     {"SetMoviePreferredRate", (PyCFunction)MovieObj_SetMoviePreferredRate, 1,
7141      PyDoc_STR("(Fixed rate) -> None")},
7142     {"GetMoviePreferredVolume", (PyCFunction)MovieObj_GetMoviePreferredVolume, 1,
7143      PyDoc_STR("() -> (short _rv)")},
7144     {"SetMoviePreferredVolume", (PyCFunction)MovieObj_SetMoviePreferredVolume, 1,
7145      PyDoc_STR("(short volume) -> None")},
7146     {"GetMovieVolume", (PyCFunction)MovieObj_GetMovieVolume, 1,
7147      PyDoc_STR("() -> (short _rv)")},
7148     {"SetMovieVolume", (PyCFunction)MovieObj_SetMovieVolume, 1,
7149      PyDoc_STR("(short volume) -> None")},
7150     {"GetMoviePreviewTime", (PyCFunction)MovieObj_GetMoviePreviewTime, 1,
7151      PyDoc_STR("() -> (TimeValue previewTime, TimeValue previewDuration)")},
7152     {"SetMoviePreviewTime", (PyCFunction)MovieObj_SetMoviePreviewTime, 1,
7153      PyDoc_STR("(TimeValue previewTime, TimeValue previewDuration) -> None")},
7154     {"GetMoviePosterTime", (PyCFunction)MovieObj_GetMoviePosterTime, 1,
7155      PyDoc_STR("() -> (TimeValue _rv)")},
7156     {"SetMoviePosterTime", (PyCFunction)MovieObj_SetMoviePosterTime, 1,
7157      PyDoc_STR("(TimeValue posterTime) -> None")},
7158     {"GetMovieSelection", (PyCFunction)MovieObj_GetMovieSelection, 1,
7159      PyDoc_STR("() -> (TimeValue selectionTime, TimeValue selectionDuration)")},
7160     {"SetMovieSelection", (PyCFunction)MovieObj_SetMovieSelection, 1,
7161      PyDoc_STR("(TimeValue selectionTime, TimeValue selectionDuration) -> None")},
7162     {"SetMovieActiveSegment", (PyCFunction)MovieObj_SetMovieActiveSegment, 1,
7163      PyDoc_STR("(TimeValue startTime, TimeValue duration) -> None")},
7164     {"GetMovieActiveSegment", (PyCFunction)MovieObj_GetMovieActiveSegment, 1,
7165      PyDoc_STR("() -> (TimeValue startTime, TimeValue duration)")},
7166     {"GetMovieTime", (PyCFunction)MovieObj_GetMovieTime, 1,
7167      PyDoc_STR("() -> (TimeValue _rv, TimeRecord currentTime)")},
7168     {"SetMovieTime", (PyCFunction)MovieObj_SetMovieTime, 1,
7169      PyDoc_STR("(TimeRecord newtime) -> None")},
7170     {"SetMovieTimeValue", (PyCFunction)MovieObj_SetMovieTimeValue, 1,
7171      PyDoc_STR("(TimeValue newtime) -> None")},
7172     {"GetMovieUserData", (PyCFunction)MovieObj_GetMovieUserData, 1,
7173      PyDoc_STR("() -> (UserData _rv)")},
7174     {"GetMovieTrackCount", (PyCFunction)MovieObj_GetMovieTrackCount, 1,
7175      PyDoc_STR("() -> (long _rv)")},
7176     {"GetMovieTrack", (PyCFunction)MovieObj_GetMovieTrack, 1,
7177      PyDoc_STR("(long trackID) -> (Track _rv)")},
7178     {"GetMovieIndTrack", (PyCFunction)MovieObj_GetMovieIndTrack, 1,
7179      PyDoc_STR("(long index) -> (Track _rv)")},
7180     {"GetMovieIndTrackType", (PyCFunction)MovieObj_GetMovieIndTrackType, 1,
7181      PyDoc_STR("(long index, OSType trackType, long flags) -> (Track _rv)")},
7182     {"NewMovieTrack", (PyCFunction)MovieObj_NewMovieTrack, 1,
7183      PyDoc_STR("(Fixed width, Fixed height, short trackVolume) -> (Track _rv)")},
7184     {"SetAutoTrackAlternatesEnabled", (PyCFunction)MovieObj_SetAutoTrackAlternatesEnabled, 1,
7185      PyDoc_STR("(Boolean enable) -> None")},
7186     {"SelectMovieAlternates", (PyCFunction)MovieObj_SelectMovieAlternates, 1,
7187      PyDoc_STR("() -> None")},
7188     {"InsertMovieSegment", (PyCFunction)MovieObj_InsertMovieSegment, 1,
7189      PyDoc_STR("(Movie dstMovie, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None")},
7190     {"InsertEmptyMovieSegment", (PyCFunction)MovieObj_InsertEmptyMovieSegment, 1,
7191      PyDoc_STR("(TimeValue dstIn, TimeValue dstDuration) -> None")},
7192     {"DeleteMovieSegment", (PyCFunction)MovieObj_DeleteMovieSegment, 1,
7193      PyDoc_STR("(TimeValue startTime, TimeValue duration) -> None")},
7194     {"ScaleMovieSegment", (PyCFunction)MovieObj_ScaleMovieSegment, 1,
7195      PyDoc_STR("(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None")},
7196     {"CutMovieSelection", (PyCFunction)MovieObj_CutMovieSelection, 1,
7197      PyDoc_STR("() -> (Movie _rv)")},
7198     {"CopyMovieSelection", (PyCFunction)MovieObj_CopyMovieSelection, 1,
7199      PyDoc_STR("() -> (Movie _rv)")},
7200     {"PasteMovieSelection", (PyCFunction)MovieObj_PasteMovieSelection, 1,
7201      PyDoc_STR("(Movie src) -> None")},
7202     {"AddMovieSelection", (PyCFunction)MovieObj_AddMovieSelection, 1,
7203      PyDoc_STR("(Movie src) -> None")},
7204     {"ClearMovieSelection", (PyCFunction)MovieObj_ClearMovieSelection, 1,
7205      PyDoc_STR("() -> None")},
7206     {"PutMovieIntoTypedHandle", (PyCFunction)MovieObj_PutMovieIntoTypedHandle, 1,
7207      PyDoc_STR("(Track targetTrack, OSType handleType, Handle publicMovie, TimeValue start, TimeValue dur, long flags, ComponentInstance userComp) -> None")},
7208     {"CopyMovieSettings", (PyCFunction)MovieObj_CopyMovieSettings, 1,
7209      PyDoc_STR("(Movie dstMovie) -> None")},
7210     {"ConvertMovieToFile", (PyCFunction)MovieObj_ConvertMovieToFile, 1,
7211      PyDoc_STR("(Track onlyTrack, FSSpec outputFile, OSType fileType, OSType creator, ScriptCode scriptTag, long flags, ComponentInstance userComp) -> (short resID)")},
7212     {"GetMovieDataSize", (PyCFunction)MovieObj_GetMovieDataSize, 1,
7213      PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (long _rv)")},
7214     {"GetMovieDataSize64", (PyCFunction)MovieObj_GetMovieDataSize64, 1,
7215      PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (wide dataSize)")},
7216     {"PtInMovie", (PyCFunction)MovieObj_PtInMovie, 1,
7217      PyDoc_STR("(Point pt) -> (Boolean _rv)")},
7218     {"SetMovieLanguage", (PyCFunction)MovieObj_SetMovieLanguage, 1,
7219      PyDoc_STR("(long language) -> None")},
7220     {"CopyMovieUserData", (PyCFunction)MovieObj_CopyMovieUserData, 1,
7221      PyDoc_STR("(Movie dstMovie, OSType copyRule) -> None")},
7222     {"GetMovieNextInterestingTime", (PyCFunction)MovieObj_GetMovieNextInterestingTime, 1,
7223      PyDoc_STR("(short interestingTimeFlags, short numMediaTypes, OSType whichMediaTypes, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)")},
7224     {"AddMovieResource", (PyCFunction)MovieObj_AddMovieResource, 1,
7225      PyDoc_STR("(short resRefNum, Str255 resName) -> (short resId)")},
7226     {"UpdateMovieResource", (PyCFunction)MovieObj_UpdateMovieResource, 1,
7227      PyDoc_STR("(short resRefNum, short resId, Str255 resName) -> None")},
7228     {"AddMovieToStorage", (PyCFunction)MovieObj_AddMovieToStorage, 1,
7229      PyDoc_STR("(DataHandler dh) -> None")},
7230     {"UpdateMovieInStorage", (PyCFunction)MovieObj_UpdateMovieInStorage, 1,
7231      PyDoc_STR("(DataHandler dh) -> None")},
7232     {"HasMovieChanged", (PyCFunction)MovieObj_HasMovieChanged, 1,
7233      PyDoc_STR("() -> (Boolean _rv)")},
7234     {"ClearMovieChanged", (PyCFunction)MovieObj_ClearMovieChanged, 1,
7235      PyDoc_STR("() -> None")},
7236     {"SetMovieDefaultDataRef", (PyCFunction)MovieObj_SetMovieDefaultDataRef, 1,
7237      PyDoc_STR("(Handle dataRef, OSType dataRefType) -> None")},
7238     {"GetMovieDefaultDataRef", (PyCFunction)MovieObj_GetMovieDefaultDataRef, 1,
7239      PyDoc_STR("() -> (Handle dataRef, OSType dataRefType)")},
7240     {"SetMovieColorTable", (PyCFunction)MovieObj_SetMovieColorTable, 1,
7241      PyDoc_STR("(CTabHandle ctab) -> None")},
7242     {"GetMovieColorTable", (PyCFunction)MovieObj_GetMovieColorTable, 1,
7243      PyDoc_STR("() -> (CTabHandle ctab)")},
7244     {"FlattenMovie", (PyCFunction)MovieObj_FlattenMovie, 1,
7245      PyDoc_STR("(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Str255 resName) -> (short resId)")},
7246     {"FlattenMovieData", (PyCFunction)MovieObj_FlattenMovieData, 1,
7247      PyDoc_STR("(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (Movie _rv)")},
7248     {"FlattenMovieDataToDataRef", (PyCFunction)MovieObj_FlattenMovieDataToDataRef, 1,
7249      PyDoc_STR("(long movieFlattenFlags, Handle dataRef, OSType dataRefType, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (Movie _rv)")},
7250     {"MovieSearchText", (PyCFunction)MovieObj_MovieSearchText, 1,
7251      PyDoc_STR("(Ptr text, long size, long searchFlags) -> (Track searchTrack, TimeValue searchTime, long searchOffset)")},
7252     {"GetPosterBox", (PyCFunction)MovieObj_GetPosterBox, 1,
7253      PyDoc_STR("() -> (Rect boxRect)")},
7254     {"SetPosterBox", (PyCFunction)MovieObj_SetPosterBox, 1,
7255      PyDoc_STR("(Rect boxRect) -> None")},
7256     {"GetMovieSegmentDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieSegmentDisplayBoundsRgn, 1,
7257      PyDoc_STR("(TimeValue time, TimeValue duration) -> (RgnHandle _rv)")},
7258     {"GetMovieStatus", (PyCFunction)MovieObj_GetMovieStatus, 1,
7259      PyDoc_STR("() -> (ComponentResult _rv, Track firstProblemTrack)")},
7260     {"NewMovieController", (PyCFunction)MovieObj_NewMovieController, 1,
7261      PyDoc_STR("(Rect movieRect, long someFlags) -> (MovieController _rv)")},
7262     {"PutMovieOnScrap", (PyCFunction)MovieObj_PutMovieOnScrap, 1,
7263      PyDoc_STR("(long movieScrapFlags) -> None")},
7264     {"SetMoviePlayHints", (PyCFunction)MovieObj_SetMoviePlayHints, 1,
7265      PyDoc_STR("(long flags, long flagsMask) -> None")},
7266     {"GetMaxLoadedTimeInMovie", (PyCFunction)MovieObj_GetMaxLoadedTimeInMovie, 1,
7267      PyDoc_STR("() -> (TimeValue time)")},
7268     {"QTMovieNeedsTimeTable", (PyCFunction)MovieObj_QTMovieNeedsTimeTable, 1,
7269      PyDoc_STR("() -> (Boolean needsTimeTable)")},
7270     {"QTGetDataRefMaxFileOffset", (PyCFunction)MovieObj_QTGetDataRefMaxFileOffset, 1,
7271      PyDoc_STR("(OSType dataRefType, Handle dataRef) -> (long offset)")},
7272     {NULL, NULL, 0}
7273 };
7274
7275 #define MovieObj_getsetlist NULL
7276
7277
7278 #define MovieObj_compare NULL
7279
7280 #define MovieObj_repr NULL
7281
7282 #define MovieObj_hash NULL
7283 #define MovieObj_tp_init 0
7284
7285 #define MovieObj_tp_alloc PyType_GenericAlloc
7286
7287 static PyObject *MovieObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
7288 {
7289     PyObject *_self;
7290     Movie itself;
7291     char *kw[] = {"itself", 0};
7292
7293     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, MovieObj_Convert, &itself)) return NULL;
7294     if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
7295     ((MovieObject *)_self)->ob_itself = itself;
7296     return _self;
7297 }
7298
7299 #define MovieObj_tp_free PyObject_Del
7300
7301
7302 PyTypeObject Movie_Type = {
7303     PyObject_HEAD_INIT(NULL)
7304     0, /*ob_size*/
7305     "_Qt.Movie", /*tp_name*/
7306     sizeof(MovieObject), /*tp_basicsize*/
7307     0, /*tp_itemsize*/
7308     /* methods */
7309     (destructor) MovieObj_dealloc, /*tp_dealloc*/
7310     0, /*tp_print*/
7311     (getattrfunc)0, /*tp_getattr*/
7312     (setattrfunc)0, /*tp_setattr*/
7313     (cmpfunc) MovieObj_compare, /*tp_compare*/
7314     (reprfunc) MovieObj_repr, /*tp_repr*/
7315     (PyNumberMethods *)0, /* tp_as_number */
7316     (PySequenceMethods *)0, /* tp_as_sequence */
7317     (PyMappingMethods *)0, /* tp_as_mapping */
7318     (hashfunc) MovieObj_hash, /*tp_hash*/
7319     0, /*tp_call*/
7320     0, /*tp_str*/
7321     PyObject_GenericGetAttr, /*tp_getattro*/
7322     PyObject_GenericSetAttr, /*tp_setattro */
7323     0, /*tp_as_buffer*/
7324     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
7325     0, /*tp_doc*/
7326     0, /*tp_traverse*/
7327     0, /*tp_clear*/
7328     0, /*tp_richcompare*/
7329     0, /*tp_weaklistoffset*/
7330     0, /*tp_iter*/
7331     0, /*tp_iternext*/
7332     MovieObj_methods, /* tp_methods */
7333     0, /*tp_members*/
7334     MovieObj_getsetlist, /*tp_getset*/
7335     0, /*tp_base*/
7336     0, /*tp_dict*/
7337     0, /*tp_descr_get*/
7338     0, /*tp_descr_set*/
7339     0, /*tp_dictoffset*/
7340     MovieObj_tp_init, /* tp_init */
7341     MovieObj_tp_alloc, /* tp_alloc */
7342     MovieObj_tp_new, /* tp_new */
7343     MovieObj_tp_free, /* tp_free */
7344 };
7345
7346 /* --------------------- End object type Movie ---------------------- */
7347
7348
7349 /* ---------------------- Object type SGOutput ---------------------- */
7350
7351 PyTypeObject SGOutput_Type;
7352
7353 #define SGOutputObj_Check(x) ((x)->ob_type == &SGOutput_Type || PyObject_TypeCheck((x), &SGOutput_Type))
7354
7355 typedef struct SGOutputObject {
7356     PyObject_HEAD
7357     SGOutput ob_itself;
7358 } SGOutputObject;
7359
7360 PyObject *SGOutputObj_New(SGOutput itself)
7361 {
7362     SGOutputObject *it;
7363     if (itself == NULL) {
7364                                     PyErr_SetString(Qt_Error,"Cannot create SGOutput from NULL pointer");
7365                                     return NULL;
7366                             }
7367     it = PyObject_NEW(SGOutputObject, &SGOutput_Type);
7368     if (it == NULL) return NULL;
7369     it->ob_itself = itself;
7370     return (PyObject *)it;
7371 }
7372
7373 int SGOutputObj_Convert(PyObject *v, SGOutput *p_itself)
7374 {
7375     if (v == Py_None)
7376     {
7377         *p_itself = NULL;
7378         return 1;
7379     }
7380     if (!SGOutputObj_Check(v))
7381     {
7382         PyErr_SetString(PyExc_TypeError, "SGOutput required");
7383         return 0;
7384     }
7385     *p_itself = ((SGOutputObject *)v)->ob_itself;
7386     return 1;
7387 }
7388
7389 static void SGOutputObj_dealloc(SGOutputObject *self)
7390 {
7391     /* Cleanup of self->ob_itself goes here */
7392     self->ob_type->tp_free((PyObject *)self);
7393 }
7394
7395 static PyMethodDef SGOutputObj_methods[] = {
7396     {NULL, NULL, 0}
7397 };
7398
7399 #define SGOutputObj_getsetlist NULL
7400
7401
7402 #define SGOutputObj_compare NULL
7403
7404 #define SGOutputObj_repr NULL
7405
7406 #define SGOutputObj_hash NULL
7407 #define SGOutputObj_tp_init 0
7408
7409 #define SGOutputObj_tp_alloc PyType_GenericAlloc
7410
7411 static PyObject *SGOutputObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)
7412 {
7413     PyObject *_self;
7414     SGOutput itself;
7415     char *kw[] = {"itself", 0};
7416
7417     if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, SGOutputObj_Convert, &itself)) return NULL;
7418     if ((_self = type->tp_alloc(type, 0)) == NULL) return NULL;
7419     ((SGOutputObject *)_self)->ob_itself = itself;
7420     return _self;
7421 }
7422
7423 #define SGOutputObj_tp_free PyObject_Del
7424
7425
7426 PyTypeObject SGOutput_Type = {
7427     PyObject_HEAD_INIT(NULL)
7428     0, /*ob_size*/
7429     "_Qt.SGOutput", /*tp_name*/
7430     sizeof(SGOutputObject), /*tp_basicsize*/
7431     0, /*tp_itemsize*/
7432     /* methods */
7433     (destructor) SGOutputObj_dealloc, /*tp_dealloc*/
7434     0, /*tp_print*/
7435     (getattrfunc)0, /*tp_getattr*/
7436     (setattrfunc)0, /*tp_setattr*/
7437     (cmpfunc) SGOutputObj_compare, /*tp_compare*/
7438     (reprfunc) SGOutputObj_repr, /*tp_repr*/
7439     (PyNumberMethods *)0, /* tp_as_number */
7440     (PySequenceMethods *)0, /* tp_as_sequence */
7441     (PyMappingMethods *)0, /* tp_as_mapping */
7442     (hashfunc) SGOutputObj_hash, /*tp_hash*/
7443     0, /*tp_call*/
7444     0, /*tp_str*/
7445     PyObject_GenericGetAttr, /*tp_getattro*/
7446     PyObject_GenericSetAttr, /*tp_setattro */
7447     0, /*tp_as_buffer*/
7448     Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
7449     0, /*tp_doc*/
7450     0, /*tp_traverse*/
7451     0, /*tp_clear*/
7452     0, /*tp_richcompare*/
7453     0, /*tp_weaklistoffset*/
7454     0, /*tp_iter*/
7455     0, /*tp_iternext*/
7456     SGOutputObj_methods, /* tp_methods */
7457     0, /*tp_members*/
7458     SGOutputObj_getsetlist, /*tp_getset*/
7459     0, /*tp_base*/
7460     0, /*tp_dict*/
7461     0, /*tp_descr_get*/
7462     0, /*tp_descr_set*/
7463     0, /*tp_dictoffset*/
7464     SGOutputObj_tp_init, /* tp_init */
7465     SGOutputObj_tp_alloc, /* tp_alloc */
7466     SGOutputObj_tp_new, /* tp_new */
7467     SGOutputObj_tp_free, /* tp_free */
7468 };
7469
7470 /* -------------------- End object type SGOutput -------------------- */
7471
7472
7473 static PyObject *Qt_EnterMovies(PyObject *_self, PyObject *_args)
7474 {
7475     PyObject *_res = NULL;
7476     OSErr _err;
7477 #ifndef EnterMovies
7478     PyMac_PRECHECK(EnterMovies);
7479 #endif
7480     if (!PyArg_ParseTuple(_args, ""))
7481         return NULL;
7482     _err = EnterMovies();
7483     if (_err != noErr) return PyMac_Error(_err);
7484     Py_INCREF(Py_None);
7485     _res = Py_None;
7486     return _res;
7487 }
7488
7489 static PyObject *Qt_ExitMovies(PyObject *_self, PyObject *_args)
7490 {
7491     PyObject *_res = NULL;
7492 #ifndef ExitMovies
7493     PyMac_PRECHECK(ExitMovies);
7494 #endif
7495     if (!PyArg_ParseTuple(_args, ""))
7496         return NULL;
7497     ExitMovies();
7498     Py_INCREF(Py_None);
7499     _res = Py_None;
7500     return _res;
7501 }
7502
7503 static PyObject *Qt_GetMoviesError(PyObject *_self, PyObject *_args)
7504 {
7505     PyObject *_res = NULL;
7506     OSErr _err;
7507 #ifndef GetMoviesError
7508     PyMac_PRECHECK(GetMoviesError);
7509 #endif
7510     if (!PyArg_ParseTuple(_args, ""))
7511         return NULL;
7512     _err = GetMoviesError();
7513     if (_err != noErr) return PyMac_Error(_err);
7514     Py_INCREF(Py_None);
7515     _res = Py_None;
7516     return _res;
7517 }
7518
7519 static PyObject *Qt_ClearMoviesStickyError(PyObject *_self, PyObject *_args)
7520 {
7521     PyObject *_res = NULL;
7522 #ifndef ClearMoviesStickyError
7523     PyMac_PRECHECK(ClearMoviesStickyError);
7524 #endif
7525     if (!PyArg_ParseTuple(_args, ""))
7526         return NULL;
7527     ClearMoviesStickyError();
7528     Py_INCREF(Py_None);
7529     _res = Py_None;
7530     return _res;
7531 }
7532
7533 static PyObject *Qt_GetMoviesStickyError(PyObject *_self, PyObject *_args)
7534 {
7535     PyObject *_res = NULL;
7536     OSErr _err;
7537 #ifndef GetMoviesStickyError
7538     PyMac_PRECHECK(GetMoviesStickyError);
7539 #endif
7540     if (!PyArg_ParseTuple(_args, ""))
7541         return NULL;
7542     _err = GetMoviesStickyError();
7543     if (_err != noErr) return PyMac_Error(_err);
7544     Py_INCREF(Py_None);
7545     _res = Py_None;
7546     return _res;
7547 }
7548
7549 static PyObject *Qt_QTGetWallClockTimeBase(PyObject *_self, PyObject *_args)
7550 {
7551     PyObject *_res = NULL;
7552     OSErr _err;
7553     TimeBase wallClockTimeBase;
7554 #ifndef QTGetWallClockTimeBase
7555     PyMac_PRECHECK(QTGetWallClockTimeBase);
7556 #endif
7557     if (!PyArg_ParseTuple(_args, ""))
7558         return NULL;
7559     _err = QTGetWallClockTimeBase(&wallClockTimeBase);
7560     if (_err != noErr) return PyMac_Error(_err);
7561     _res = Py_BuildValue("O&",
7562                          TimeBaseObj_New, wallClockTimeBase);
7563     return _res;
7564 }
7565
7566 static PyObject *Qt_QTIdleManagerOpen(PyObject *_self, PyObject *_args)
7567 {
7568     PyObject *_res = NULL;
7569     IdleManager _rv;
7570 #ifndef QTIdleManagerOpen
7571     PyMac_PRECHECK(QTIdleManagerOpen);
7572 #endif
7573     if (!PyArg_ParseTuple(_args, ""))
7574         return NULL;
7575     _rv = QTIdleManagerOpen();
7576     _res = Py_BuildValue("O&",
7577                          IdleManagerObj_New, _rv);
7578     return _res;
7579 }
7580
7581 static PyObject *Qt_CreateMovieControl(PyObject *_self, PyObject *_args)
7582 {
7583     PyObject *_res = NULL;
7584     OSErr _err;
7585     WindowPtr theWindow;
7586     Rect localRect;
7587     Movie theMovie;
7588     UInt32 options;
7589     ControlHandle returnedControl;
7590 #ifndef CreateMovieControl
7591     PyMac_PRECHECK(CreateMovieControl);
7592 #endif
7593     if (!PyArg_ParseTuple(_args, "O&O&l",
7594                           WinObj_Convert, &theWindow,
7595                           MovieObj_Convert, &theMovie,
7596                           &options))
7597         return NULL;
7598     _err = CreateMovieControl(theWindow,
7599                               &localRect,
7600                               theMovie,
7601                               options,
7602                               &returnedControl);
7603     if (_err != noErr) return PyMac_Error(_err);
7604     _res = Py_BuildValue("O&O&",
7605                          PyMac_BuildRect, &localRect,
7606                          CtlObj_New, returnedControl);
7607     return _res;
7608 }
7609
7610 static PyObject *Qt_DisposeMatte(PyObject *_self, PyObject *_args)
7611 {
7612     PyObject *_res = NULL;
7613     PixMapHandle theMatte;
7614 #ifndef DisposeMatte
7615     PyMac_PRECHECK(DisposeMatte);
7616 #endif
7617     if (!PyArg_ParseTuple(_args, "O&",
7618                           ResObj_Convert, &theMatte))
7619         return NULL;
7620     DisposeMatte(theMatte);
7621     Py_INCREF(Py_None);
7622     _res = Py_None;
7623     return _res;
7624 }
7625
7626 static PyObject *Qt_NewMovie(PyObject *_self, PyObject *_args)
7627 {
7628     PyObject *_res = NULL;
7629     Movie _rv;
7630     long flags;
7631 #ifndef NewMovie
7632     PyMac_PRECHECK(NewMovie);
7633 #endif
7634     if (!PyArg_ParseTuple(_args, "l",
7635                           &flags))
7636         return NULL;
7637     _rv = NewMovie(flags);
7638     _res = Py_BuildValue("O&",
7639                          MovieObj_New, _rv);
7640     return _res;
7641 }
7642
7643 static PyObject *Qt_QTGetTimeUntilNextTask(PyObject *_self, PyObject *_args)
7644 {
7645     PyObject *_res = NULL;
7646     OSErr _err;
7647     long duration;
7648     long scale;
7649 #ifndef QTGetTimeUntilNextTask
7650     PyMac_PRECHECK(QTGetTimeUntilNextTask);
7651 #endif
7652     if (!PyArg_ParseTuple(_args, "l",
7653                           &scale))
7654         return NULL;
7655     _err = QTGetTimeUntilNextTask(&duration,
7656                                   scale);
7657     if (_err != noErr) return PyMac_Error(_err);
7658     _res = Py_BuildValue("l",
7659                          duration);
7660     return _res;
7661 }
7662
7663 static PyObject *Qt_GetDataHandler(PyObject *_self, PyObject *_args)
7664 {
7665     PyObject *_res = NULL;
7666     Component _rv;
7667     Handle dataRef;
7668     OSType dataHandlerSubType;
7669     long flags;
7670 #ifndef GetDataHandler
7671     PyMac_PRECHECK(GetDataHandler);
7672 #endif
7673     if (!PyArg_ParseTuple(_args, "O&O&l",
7674                           ResObj_Convert, &dataRef,
7675                           PyMac_GetOSType, &dataHandlerSubType,
7676                           &flags))
7677         return NULL;
7678     _rv = GetDataHandler(dataRef,
7679                          dataHandlerSubType,
7680                          flags);
7681     _res = Py_BuildValue("O&",
7682                          CmpObj_New, _rv);
7683     return _res;
7684 }
7685
7686 static PyObject *Qt_PasteHandleIntoMovie(PyObject *_self, PyObject *_args)
7687 {
7688     PyObject *_res = NULL;
7689     OSErr _err;
7690     Handle h;
7691     OSType handleType;
7692     Movie theMovie;
7693     long flags;
7694     ComponentInstance userComp;
7695 #ifndef PasteHandleIntoMovie
7696     PyMac_PRECHECK(PasteHandleIntoMovie);
7697 #endif
7698     if (!PyArg_ParseTuple(_args, "O&O&O&lO&",
7699                           ResObj_Convert, &h,
7700                           PyMac_GetOSType, &handleType,
7701                           MovieObj_Convert, &theMovie,
7702                           &flags,
7703                           CmpInstObj_Convert, &userComp))
7704         return NULL;
7705     _err = PasteHandleIntoMovie(h,
7706                                 handleType,
7707                                 theMovie,
7708                                 flags,
7709                                 userComp);
7710     if (_err != noErr) return PyMac_Error(_err);
7711     Py_INCREF(Py_None);
7712     _res = Py_None;
7713     return _res;
7714 }
7715
7716 static PyObject *Qt_GetMovieImporterForDataRef(PyObject *_self, PyObject *_args)
7717 {
7718     PyObject *_res = NULL;
7719     OSErr _err;
7720     OSType dataRefType;
7721     Handle dataRef;
7722     long flags;
7723     Component importer;
7724 #ifndef GetMovieImporterForDataRef
7725     PyMac_PRECHECK(GetMovieImporterForDataRef);
7726 #endif
7727     if (!PyArg_ParseTuple(_args, "O&O&l",
7728                           PyMac_GetOSType, &dataRefType,
7729                           ResObj_Convert, &dataRef,
7730                           &flags))
7731         return NULL;
7732     _err = GetMovieImporterForDataRef(dataRefType,
7733                                       dataRef,
7734                                       flags,
7735                                       &importer);
7736     if (_err != noErr) return PyMac_Error(_err);
7737     _res = Py_BuildValue("O&",
7738                          CmpObj_New, importer);
7739     return _res;
7740 }
7741
7742 static PyObject *Qt_QTGetMIMETypeInfo(PyObject *_self, PyObject *_args)
7743 {
7744     PyObject *_res = NULL;
7745     OSErr _err;
7746     char* mimeStringStart;
7747     short mimeStringLength;
7748     OSType infoSelector;
7749     void * infoDataPtr;
7750     long infoDataSize;
7751 #ifndef QTGetMIMETypeInfo
7752     PyMac_PRECHECK(QTGetMIMETypeInfo);
7753 #endif
7754     if (!PyArg_ParseTuple(_args, "shO&s",
7755                           &mimeStringStart,
7756                           &mimeStringLength,
7757                           PyMac_GetOSType, &infoSelector,
7758                           &infoDataPtr))
7759         return NULL;
7760     _err = QTGetMIMETypeInfo(mimeStringStart,
7761                              mimeStringLength,
7762                              infoSelector,
7763                              infoDataPtr,
7764                              &infoDataSize);
7765     if (_err != noErr) return PyMac_Error(_err);
7766     _res = Py_BuildValue("l",
7767                          infoDataSize);
7768     return _res;
7769 }
7770
7771 static PyObject *Qt_TrackTimeToMediaTime(PyObject *_self, PyObject *_args)
7772 {
7773     PyObject *_res = NULL;
7774     TimeValue _rv;
7775     TimeValue value;
7776     Track theTrack;
7777 #ifndef TrackTimeToMediaTime
7778     PyMac_PRECHECK(TrackTimeToMediaTime);
7779 #endif
7780     if (!PyArg_ParseTuple(_args, "lO&",
7781                           &value,
7782                           TrackObj_Convert, &theTrack))
7783         return NULL;
7784     _rv = TrackTimeToMediaTime(value,
7785                                theTrack);
7786     _res = Py_BuildValue("l",
7787                          _rv);
7788     return _res;
7789 }
7790
7791 static PyObject *Qt_NewUserData(PyObject *_self, PyObject *_args)
7792 {
7793     PyObject *_res = NULL;
7794     OSErr _err;
7795     UserData theUserData;
7796 #ifndef NewUserData
7797     PyMac_PRECHECK(NewUserData);
7798 #endif
7799     if (!PyArg_ParseTuple(_args, ""))
7800         return NULL;
7801     _err = NewUserData(&theUserData);
7802     if (_err != noErr) return PyMac_Error(_err);
7803     _res = Py_BuildValue("O&",
7804                          UserDataObj_New, theUserData);
7805     return _res;
7806 }
7807
7808 static PyObject *Qt_NewUserDataFromHandle(PyObject *_self, PyObject *_args)
7809 {
7810     PyObject *_res = NULL;
7811     OSErr _err;
7812     Handle h;
7813     UserData theUserData;
7814 #ifndef NewUserDataFromHandle
7815     PyMac_PRECHECK(NewUserDataFromHandle);
7816 #endif
7817     if (!PyArg_ParseTuple(_args, "O&",
7818                           ResObj_Convert, &h))
7819         return NULL;
7820     _err = NewUserDataFromHandle(h,
7821                                  &theUserData);
7822     if (_err != noErr) return PyMac_Error(_err);
7823     _res = Py_BuildValue("O&",
7824                          UserDataObj_New, theUserData);
7825     return _res;
7826 }
7827
7828 static PyObject *Qt_CreateMovieFile(PyObject *_self, PyObject *_args)
7829 {
7830     PyObject *_res = NULL;
7831     OSErr _err;
7832     FSSpec fileSpec;
7833     OSType creator;
7834     ScriptCode scriptTag;
7835     long createMovieFileFlags;
7836     short resRefNum;
7837     Movie newmovie;
7838 #ifndef CreateMovieFile
7839     PyMac_PRECHECK(CreateMovieFile);
7840 #endif
7841     if (!PyArg_ParseTuple(_args, "O&O&hl",
7842                           PyMac_GetFSSpec, &fileSpec,
7843                           PyMac_GetOSType, &creator,
7844                           &scriptTag,
7845                           &createMovieFileFlags))
7846         return NULL;
7847     _err = CreateMovieFile(&fileSpec,
7848                            creator,
7849                            scriptTag,
7850                            createMovieFileFlags,
7851                            &resRefNum,
7852                            &newmovie);
7853     if (_err != noErr) return PyMac_Error(_err);
7854     _res = Py_BuildValue("hO&",
7855                          resRefNum,
7856                          MovieObj_New, newmovie);
7857     return _res;
7858 }
7859
7860 static PyObject *Qt_OpenMovieFile(PyObject *_self, PyObject *_args)
7861 {
7862     PyObject *_res = NULL;
7863     OSErr _err;
7864     FSSpec fileSpec;
7865     short resRefNum;
7866     SInt8 permission;
7867 #ifndef OpenMovieFile
7868     PyMac_PRECHECK(OpenMovieFile);
7869 #endif
7870     if (!PyArg_ParseTuple(_args, "O&b",
7871                           PyMac_GetFSSpec, &fileSpec,
7872                           &permission))
7873         return NULL;
7874     _err = OpenMovieFile(&fileSpec,
7875                          &resRefNum,
7876                          permission);
7877     if (_err != noErr) return PyMac_Error(_err);
7878     _res = Py_BuildValue("h",
7879                          resRefNum);
7880     return _res;
7881 }
7882
7883 static PyObject *Qt_CloseMovieFile(PyObject *_self, PyObject *_args)
7884 {
7885     PyObject *_res = NULL;
7886     OSErr _err;
7887     short resRefNum;
7888 #ifndef CloseMovieFile
7889     PyMac_PRECHECK(CloseMovieFile);
7890 #endif
7891     if (!PyArg_ParseTuple(_args, "h",
7892                           &resRefNum))
7893         return NULL;
7894     _err = CloseMovieFile(resRefNum);
7895     if (_err != noErr) return PyMac_Error(_err);
7896     Py_INCREF(Py_None);
7897     _res = Py_None;
7898     return _res;
7899 }
7900
7901 static PyObject *Qt_DeleteMovieFile(PyObject *_self, PyObject *_args)
7902 {
7903     PyObject *_res = NULL;
7904     OSErr _err;
7905     FSSpec fileSpec;
7906 #ifndef DeleteMovieFile
7907     PyMac_PRECHECK(DeleteMovieFile);
7908 #endif
7909     if (!PyArg_ParseTuple(_args, "O&",
7910                           PyMac_GetFSSpec, &fileSpec))
7911         return NULL;
7912     _err = DeleteMovieFile(&fileSpec);
7913     if (_err != noErr) return PyMac_Error(_err);
7914     Py_INCREF(Py_None);
7915     _res = Py_None;
7916     return _res;
7917 }
7918
7919 static PyObject *Qt_NewMovieFromFile(PyObject *_self, PyObject *_args)
7920 {
7921     PyObject *_res = NULL;
7922     OSErr _err;
7923     Movie theMovie;
7924     short resRefNum;
7925     short resId;
7926     short newMovieFlags;
7927     Boolean dataRefWasChanged;
7928 #ifndef NewMovieFromFile
7929     PyMac_PRECHECK(NewMovieFromFile);
7930 #endif
7931     if (!PyArg_ParseTuple(_args, "hhh",
7932                           &resRefNum,
7933                           &resId,
7934                           &newMovieFlags))
7935         return NULL;
7936     _err = NewMovieFromFile(&theMovie,
7937                             resRefNum,
7938                             &resId,
7939                             (StringPtr)0,
7940                             newMovieFlags,
7941                             &dataRefWasChanged);
7942     if (_err != noErr) return PyMac_Error(_err);
7943     _res = Py_BuildValue("O&hb",
7944                          MovieObj_New, theMovie,
7945                          resId,
7946                          dataRefWasChanged);
7947     return _res;
7948 }
7949
7950 static PyObject *Qt_NewMovieFromHandle(PyObject *_self, PyObject *_args)
7951 {
7952     PyObject *_res = NULL;
7953     OSErr _err;
7954     Movie theMovie;
7955     Handle h;
7956     short newMovieFlags;
7957     Boolean dataRefWasChanged;
7958 #ifndef NewMovieFromHandle
7959     PyMac_PRECHECK(NewMovieFromHandle);
7960 #endif
7961     if (!PyArg_ParseTuple(_args, "O&h",
7962                           ResObj_Convert, &h,
7963                           &newMovieFlags))
7964         return NULL;
7965     _err = NewMovieFromHandle(&theMovie,
7966                               h,
7967                               newMovieFlags,
7968                               &dataRefWasChanged);
7969     if (_err != noErr) return PyMac_Error(_err);
7970     _res = Py_BuildValue("O&b",
7971                          MovieObj_New, theMovie,
7972                          dataRefWasChanged);
7973     return _res;
7974 }
7975
7976 static PyObject *Qt_NewMovieFromDataFork(PyObject *_self, PyObject *_args)
7977 {
7978     PyObject *_res = NULL;
7979     OSErr _err;
7980     Movie theMovie;
7981     short fRefNum;
7982     long fileOffset;
7983     short newMovieFlags;
7984     Boolean dataRefWasChanged;
7985 #ifndef NewMovieFromDataFork
7986     PyMac_PRECHECK(NewMovieFromDataFork);
7987 #endif
7988     if (!PyArg_ParseTuple(_args, "hlh",
7989                           &fRefNum,
7990                           &fileOffset,
7991                           &newMovieFlags))
7992         return NULL;
7993     _err = NewMovieFromDataFork(&theMovie,
7994                                 fRefNum,
7995                                 fileOffset,
7996                                 newMovieFlags,
7997                                 &dataRefWasChanged);
7998     if (_err != noErr) return PyMac_Error(_err);
7999     _res = Py_BuildValue("O&b",
8000                          MovieObj_New, theMovie,
8001                          dataRefWasChanged);
8002     return _res;
8003 }
8004
8005 static PyObject *Qt_NewMovieFromDataFork64(PyObject *_self, PyObject *_args)
8006 {
8007     PyObject *_res = NULL;
8008     OSErr _err;
8009     Movie theMovie;
8010     long fRefNum;
8011     wide fileOffset;
8012     short newMovieFlags;
8013     Boolean dataRefWasChanged;
8014 #ifndef NewMovieFromDataFork64
8015     PyMac_PRECHECK(NewMovieFromDataFork64);
8016 #endif
8017     if (!PyArg_ParseTuple(_args, "lO&h",
8018                           &fRefNum,
8019                           PyMac_Getwide, &fileOffset,
8020                           &newMovieFlags))
8021         return NULL;
8022     _err = NewMovieFromDataFork64(&theMovie,
8023                                   fRefNum,
8024                                   &fileOffset,
8025                                   newMovieFlags,
8026                                   &dataRefWasChanged);
8027     if (_err != noErr) return PyMac_Error(_err);
8028     _res = Py_BuildValue("O&b",
8029                          MovieObj_New, theMovie,
8030                          dataRefWasChanged);
8031     return _res;
8032 }
8033
8034 static PyObject *Qt_NewMovieFromDataRef(PyObject *_self, PyObject *_args)
8035 {
8036     PyObject *_res = NULL;
8037     OSErr _err;
8038     Movie m;
8039     short flags;
8040     short id;
8041     Handle dataRef;
8042     OSType dtaRefType;
8043 #ifndef NewMovieFromDataRef
8044     PyMac_PRECHECK(NewMovieFromDataRef);
8045 #endif
8046     if (!PyArg_ParseTuple(_args, "hO&O&",
8047                           &flags,
8048                           ResObj_Convert, &dataRef,
8049                           PyMac_GetOSType, &dtaRefType))
8050         return NULL;
8051     _err = NewMovieFromDataRef(&m,
8052                                flags,
8053                                &id,
8054                                dataRef,
8055                                dtaRefType);
8056     if (_err != noErr) return PyMac_Error(_err);
8057     _res = Py_BuildValue("O&h",
8058                          MovieObj_New, m,
8059                          id);
8060     return _res;
8061 }
8062
8063 static PyObject *Qt_NewMovieFromStorageOffset(PyObject *_self, PyObject *_args)
8064 {
8065     PyObject *_res = NULL;
8066     OSErr _err;
8067     Movie theMovie;
8068     DataHandler dh;
8069     wide fileOffset;
8070     short newMovieFlags;
8071     Boolean dataRefWasCataRefType;
8072 #ifndef NewMovieFromStorageOffset
8073     PyMac_PRECHECK(NewMovieFromStorageOffset);
8074 #endif
8075     if (!PyArg_ParseTuple(_args, "O&O&h",
8076                           CmpInstObj_Convert, &dh,
8077                           PyMac_Getwide, &fileOffset,
8078                           &newMovieFlags))
8079         return NULL;
8080     _err = NewMovieFromStorageOffset(&theMovie,
8081                                      dh,
8082                                      &fileOffset,
8083                                      newMovieFlags,
8084                                      &dataRefWasCataRefType);
8085     if (_err != noErr) return PyMac_Error(_err);
8086     _res = Py_BuildValue("O&b",
8087                          MovieObj_New, theMovie,
8088                          dataRefWasCataRefType);
8089     return _res;
8090 }
8091
8092 static PyObject *Qt_NewMovieForDataRefFromHandle(PyObject *_self, PyObject *_args)
8093 {
8094     PyObject *_res = NULL;
8095     OSErr _err;
8096     Movie theMovie;
8097     Handle h;
8098     short newMovieFlags;
8099     Boolean dataRefWasChanged;
8100     Handle dataRef;
8101     OSType dataRefType;
8102 #ifndef NewMovieForDataRefFromHandle
8103     PyMac_PRECHECK(NewMovieForDataRefFromHandle);
8104 #endif
8105     if (!PyArg_ParseTuple(_args, "O&hO&O&",
8106                           ResObj_Convert, &h,
8107                           &newMovieFlags,
8108                           ResObj_Convert, &dataRef,
8109                           PyMac_GetOSType, &dataRefType))
8110         return NULL;
8111     _err = NewMovieForDataRefFromHandle(&theMovie,
8112                                         h,
8113                                         newMovieFlags,
8114                                         &dataRefWasChanged,
8115                                         dataRef,
8116                                         dataRefType);
8117     if (_err != noErr) return PyMac_Error(_err);
8118     _res = Py_BuildValue("O&b",
8119                          MovieObj_New, theMovie,
8120                          dataRefWasChanged);
8121     return _res;
8122 }
8123
8124 static PyObject *Qt_RemoveMovieResource(PyObject *_self, PyObject *_args)
8125 {
8126     PyObject *_res = NULL;
8127     OSErr _err;
8128     short resRefNum;
8129     short resId;
8130 #ifndef RemoveMovieResource
8131     PyMac_PRECHECK(RemoveMovieResource);
8132 #endif
8133     if (!PyArg_ParseTuple(_args, "hh",
8134                           &resRefNum,
8135                           &resId))
8136         return NULL;
8137     _err = RemoveMovieResource(resRefNum,
8138                                resId);
8139     if (_err != noErr) return PyMac_Error(_err);
8140     Py_INCREF(Py_None);
8141     _res = Py_None;
8142     return _res;
8143 }
8144
8145 static PyObject *Qt_CreateMovieStorage(PyObject *_self, PyObject *_args)
8146 {
8147     PyObject *_res = NULL;
8148     OSErr _err;
8149     Handle dataRef;
8150     OSType dataRefType;
8151     OSType creator;
8152     ScriptCode scriptTag;
8153     long createMovieFileFlags;
8154     DataHandler outDataHandler;
8155     Movie newmovie;
8156 #ifndef CreateMovieStorage
8157     PyMac_PRECHECK(CreateMovieStorage);
8158 #endif
8159     if (!PyArg_ParseTuple(_args, "O&O&O&hl",
8160                           ResObj_Convert, &dataRef,
8161                           PyMac_GetOSType, &dataRefType,
8162                           PyMac_GetOSType, &creator,
8163                           &scriptTag,
8164                           &createMovieFileFlags))
8165         return NULL;
8166     _err = CreateMovieStorage(dataRef,
8167                               dataRefType,
8168                               creator,
8169                               scriptTag,
8170                               createMovieFileFlags,
8171                               &outDataHandler,
8172                               &newmovie);
8173     if (_err != noErr) return PyMac_Error(_err);
8174     _res = Py_BuildValue("O&O&",
8175                          CmpInstObj_New, outDataHandler,
8176                          MovieObj_New, newmovie);
8177     return _res;
8178 }
8179
8180 static PyObject *Qt_OpenMovieStorage(PyObject *_self, PyObject *_args)
8181 {
8182     PyObject *_res = NULL;
8183     OSErr _err;
8184     Handle dataRef;
8185     OSType dataRefType;
8186     long flags;
8187     DataHandler outDataHandler;
8188 #ifndef OpenMovieStorage
8189     PyMac_PRECHECK(OpenMovieStorage);
8190 #endif
8191     if (!PyArg_ParseTuple(_args, "O&O&l",
8192                           ResObj_Convert, &dataRef,
8193                           PyMac_GetOSType, &dataRefType,
8194                           &flags))
8195         return NULL;
8196     _err = OpenMovieStorage(dataRef,
8197                             dataRefType,
8198                             flags,
8199                             &outDataHandler);
8200     if (_err != noErr) return PyMac_Error(_err);
8201     _res = Py_BuildValue("O&",
8202                          CmpInstObj_New, outDataHandler);
8203     return _res;
8204 }
8205
8206 static PyObject *Qt_CloseMovieStorage(PyObject *_self, PyObject *_args)
8207 {
8208     PyObject *_res = NULL;
8209     OSErr _err;
8210     DataHandler dh;
8211 #ifndef CloseMovieStorage
8212     PyMac_PRECHECK(CloseMovieStorage);
8213 #endif
8214     if (!PyArg_ParseTuple(_args, "O&",
8215                           CmpInstObj_Convert, &dh))
8216         return NULL;
8217     _err = CloseMovieStorage(dh);
8218     if (_err != noErr) return PyMac_Error(_err);
8219     Py_INCREF(Py_None);
8220     _res = Py_None;
8221     return _res;
8222 }
8223
8224 static PyObject *Qt_DeleteMovieStorage(PyObject *_self, PyObject *_args)
8225 {
8226     PyObject *_res = NULL;
8227     OSErr _err;
8228     Handle dataRef;
8229     OSType dataRefType;
8230 #ifndef DeleteMovieStorage
8231     PyMac_PRECHECK(DeleteMovieStorage);
8232 #endif
8233     if (!PyArg_ParseTuple(_args, "O&O&",
8234                           ResObj_Convert, &dataRef,
8235                           PyMac_GetOSType, &dataRefType))
8236         return NULL;
8237     _err = DeleteMovieStorage(dataRef,
8238                               dataRefType);
8239     if (_err != noErr) return PyMac_Error(_err);
8240     Py_INCREF(Py_None);
8241     _res = Py_None;
8242     return _res;
8243 }
8244
8245 static PyObject *Qt_CreateShortcutMovieFile(PyObject *_self, PyObject *_args)
8246 {
8247     PyObject *_res = NULL;
8248     OSErr _err;
8249     FSSpec fileSpec;
8250     OSType creator;
8251     ScriptCode scriptTag;
8252     long createMovieFileFlags;
8253     Handle targetDataRef;
8254     OSType targetDataRefType;
8255 #ifndef CreateShortcutMovieFile
8256     PyMac_PRECHECK(CreateShortcutMovieFile);
8257 #endif
8258     if (!PyArg_ParseTuple(_args, "O&O&hlO&O&",
8259                           PyMac_GetFSSpec, &fileSpec,
8260                           PyMac_GetOSType, &creator,
8261                           &scriptTag,
8262                           &createMovieFileFlags,
8263                           ResObj_Convert, &targetDataRef,
8264                           PyMac_GetOSType, &targetDataRefType))
8265         return NULL;
8266     _err = CreateShortcutMovieFile(&fileSpec,
8267                                    creator,
8268                                    scriptTag,
8269                                    createMovieFileFlags,
8270                                    targetDataRef,
8271                                    targetDataRefType);
8272     if (_err != noErr) return PyMac_Error(_err);
8273     Py_INCREF(Py_None);
8274     _res = Py_None;
8275     return _res;
8276 }
8277
8278 static PyObject *Qt_CanQuickTimeOpenFile(PyObject *_self, PyObject *_args)
8279 {
8280     PyObject *_res = NULL;
8281     OSErr _err;
8282     FSSpec fileSpec;
8283     OSType fileType;
8284     OSType fileNameExtension;
8285     Boolean outCanOpenWithGraphicsImporter;
8286     Boolean outCanOpenAsMovie;
8287     Boolean outPreferGraphicsImporter;
8288     UInt32 inFlags;
8289 #ifndef CanQuickTimeOpenFile
8290     PyMac_PRECHECK(CanQuickTimeOpenFile);
8291 #endif
8292     if (!PyArg_ParseTuple(_args, "O&O&O&l",
8293                           PyMac_GetFSSpec, &fileSpec,
8294                           PyMac_GetOSType, &fileType,
8295                           PyMac_GetOSType, &fileNameExtension,
8296                           &inFlags))
8297         return NULL;
8298     _err = CanQuickTimeOpenFile(&fileSpec,
8299                                 fileType,
8300                                 fileNameExtension,
8301                                 &outCanOpenWithGraphicsImporter,
8302                                 &outCanOpenAsMovie,
8303                                 &outPreferGraphicsImporter,
8304                                 inFlags);
8305     if (_err != noErr) return PyMac_Error(_err);
8306     _res = Py_BuildValue("bbb",
8307                          outCanOpenWithGraphicsImporter,
8308                          outCanOpenAsMovie,
8309                          outPreferGraphicsImporter);
8310     return _res;
8311 }
8312
8313 static PyObject *Qt_CanQuickTimeOpenDataRef(PyObject *_self, PyObject *_args)
8314 {
8315     PyObject *_res = NULL;
8316     OSErr _err;
8317     Handle dataRef;
8318     OSType dataRefType;
8319     Boolean outCanOpenWithGraphicsImporter;
8320     Boolean outCanOpenAsMovie;
8321     Boolean outPreferGraphicsImporter;
8322     UInt32 inFlags;
8323 #ifndef CanQuickTimeOpenDataRef
8324     PyMac_PRECHECK(CanQuickTimeOpenDataRef);
8325 #endif
8326     if (!PyArg_ParseTuple(_args, "O&O&l",
8327                           ResObj_Convert, &dataRef,
8328                           PyMac_GetOSType, &dataRefType,
8329                           &inFlags))
8330         return NULL;
8331     _err = CanQuickTimeOpenDataRef(dataRef,
8332                                    dataRefType,
8333                                    &outCanOpenWithGraphicsImporter,
8334                                    &outCanOpenAsMovie,
8335                                    &outPreferGraphicsImporter,
8336                                    inFlags);
8337     if (_err != noErr) return PyMac_Error(_err);
8338     _res = Py_BuildValue("bbb",
8339                          outCanOpenWithGraphicsImporter,
8340                          outCanOpenAsMovie,
8341                          outPreferGraphicsImporter);
8342     return _res;
8343 }
8344
8345 static PyObject *Qt_NewMovieFromScrap(PyObject *_self, PyObject *_args)
8346 {
8347     PyObject *_res = NULL;
8348     Movie _rv;
8349     long newMovieFlags;
8350 #ifndef NewMovieFromScrap
8351     PyMac_PRECHECK(NewMovieFromScrap);
8352 #endif
8353     if (!PyArg_ParseTuple(_args, "l",
8354                           &newMovieFlags))
8355         return NULL;
8356     _rv = NewMovieFromScrap(newMovieFlags);
8357     _res = Py_BuildValue("O&",
8358                          MovieObj_New, _rv);
8359     return _res;
8360 }
8361
8362 static PyObject *Qt_QTNewAlias(PyObject *_self, PyObject *_args)
8363 {
8364     PyObject *_res = NULL;
8365     OSErr _err;
8366     FSSpec fss;
8367     AliasHandle alias;
8368     Boolean minimal;
8369 #ifndef QTNewAlias
8370     PyMac_PRECHECK(QTNewAlias);
8371 #endif
8372     if (!PyArg_ParseTuple(_args, "O&b",
8373                           PyMac_GetFSSpec, &fss,
8374                           &minimal))
8375         return NULL;
8376     _err = QTNewAlias(&fss,
8377                       &alias,
8378                       minimal);
8379     if (_err != noErr) return PyMac_Error(_err);
8380     _res = Py_BuildValue("O&",
8381                          ResObj_New, alias);
8382     return _res;
8383 }
8384
8385 static PyObject *Qt_EndFullScreen(PyObject *_self, PyObject *_args)
8386 {
8387     PyObject *_res = NULL;
8388     OSErr _err;
8389     Ptr fullState;
8390     long flags;
8391 #ifndef EndFullScreen
8392     PyMac_PRECHECK(EndFullScreen);
8393 #endif
8394     if (!PyArg_ParseTuple(_args, "sl",
8395                           &fullState,
8396                           &flags))
8397         return NULL;
8398     _err = EndFullScreen(fullState,
8399                          flags);
8400     if (_err != noErr) return PyMac_Error(_err);
8401     Py_INCREF(Py_None);
8402     _res = Py_None;
8403     return _res;
8404 }
8405
8406 static PyObject *Qt_AddSoundDescriptionExtension(PyObject *_self, PyObject *_args)
8407 {
8408     PyObject *_res = NULL;
8409     OSErr _err;
8410     SoundDescriptionHandle desc;
8411     Handle extension;
8412     OSType idType;
8413 #ifndef AddSoundDescriptionExtension
8414     PyMac_PRECHECK(AddSoundDescriptionExtension);
8415 #endif
8416     if (!PyArg_ParseTuple(_args, "O&O&O&",
8417                           ResObj_Convert, &desc,
8418                           ResObj_Convert, &extension,
8419                           PyMac_GetOSType, &idType))
8420         return NULL;
8421     _err = AddSoundDescriptionExtension(desc,
8422                                         extension,
8423                                         idType);
8424     if (_err != noErr) return PyMac_Error(_err);
8425     Py_INCREF(Py_None);
8426     _res = Py_None;
8427     return _res;
8428 }
8429
8430 static PyObject *Qt_GetSoundDescriptionExtension(PyObject *_self, PyObject *_args)
8431 {
8432     PyObject *_res = NULL;
8433     OSErr _err;
8434     SoundDescriptionHandle desc;
8435     Handle extension;
8436     OSType idType;
8437 #ifndef GetSoundDescriptionExtension
8438     PyMac_PRECHECK(GetSoundDescriptionExtension);
8439 #endif
8440     if (!PyArg_ParseTuple(_args, "O&O&",
8441                           ResObj_Convert, &desc,
8442                           PyMac_GetOSType, &idType))
8443         return NULL;
8444     _err = GetSoundDescriptionExtension(desc,
8445                                         &extension,
8446                                         idType);
8447     if (_err != noErr) return PyMac_Error(_err);
8448     _res = Py_BuildValue("O&",
8449                          ResObj_New, extension);
8450     return _res;
8451 }
8452
8453 static PyObject *Qt_RemoveSoundDescriptionExtension(PyObject *_self, PyObject *_args)
8454 {
8455     PyObject *_res = NULL;
8456     OSErr _err;
8457     SoundDescriptionHandle desc;
8458     OSType idType;
8459 #ifndef RemoveSoundDescriptionExtension
8460     PyMac_PRECHECK(RemoveSoundDescriptionExtension);
8461 #endif
8462     if (!PyArg_ParseTuple(_args, "O&O&",
8463                           ResObj_Convert, &desc,
8464                           PyMac_GetOSType, &idType))
8465         return NULL;
8466     _err = RemoveSoundDescriptionExtension(desc,
8467                                            idType);
8468     if (_err != noErr) return PyMac_Error(_err);
8469     Py_INCREF(Py_None);
8470     _res = Py_None;
8471     return _res;
8472 }
8473
8474 static PyObject *Qt_QTIsStandardParameterDialogEvent(PyObject *_self, PyObject *_args)
8475 {
8476     PyObject *_res = NULL;
8477     OSErr _err;
8478     EventRecord pEvent;
8479     QTParameterDialog createdDialog;
8480 #ifndef QTIsStandardParameterDialogEvent
8481     PyMac_PRECHECK(QTIsStandardParameterDialogEvent);
8482 #endif
8483     if (!PyArg_ParseTuple(_args, "l",
8484                           &createdDialog))
8485         return NULL;
8486     _err = QTIsStandardParameterDialogEvent(&pEvent,
8487                                             createdDialog);
8488     if (_err != noErr) return PyMac_Error(_err);
8489     _res = Py_BuildValue("O&",
8490                          PyMac_BuildEventRecord, &pEvent);
8491     return _res;
8492 }
8493
8494 static PyObject *Qt_QTDismissStandardParameterDialog(PyObject *_self, PyObject *_args)
8495 {
8496     PyObject *_res = NULL;
8497     OSErr _err;
8498     QTParameterDialog createdDialog;
8499 #ifndef QTDismissStandardParameterDialog
8500     PyMac_PRECHECK(QTDismissStandardParameterDialog);
8501 #endif
8502     if (!PyArg_ParseTuple(_args, "l",
8503                           &createdDialog))
8504         return NULL;
8505     _err = QTDismissStandardParameterDialog(createdDialog);
8506     if (_err != noErr) return PyMac_Error(_err);
8507     Py_INCREF(Py_None);
8508     _res = Py_None;
8509     return _res;
8510 }
8511
8512 static PyObject *Qt_QTStandardParameterDialogDoAction(PyObject *_self, PyObject *_args)
8513 {
8514     PyObject *_res = NULL;
8515     OSErr _err;
8516     QTParameterDialog createdDialog;
8517     long action;
8518     void * params;
8519 #ifndef QTStandardParameterDialogDoAction
8520     PyMac_PRECHECK(QTStandardParameterDialogDoAction);
8521 #endif
8522     if (!PyArg_ParseTuple(_args, "lls",
8523                           &createdDialog,
8524                           &action,
8525                           &params))
8526         return NULL;
8527     _err = QTStandardParameterDialogDoAction(createdDialog,
8528                                              action,
8529                                              params);
8530     if (_err != noErr) return PyMac_Error(_err);
8531     Py_INCREF(Py_None);
8532     _res = Py_None;
8533     return _res;
8534 }
8535
8536 static PyObject *Qt_QTRegisterAccessKey(PyObject *_self, PyObject *_args)
8537 {
8538     PyObject *_res = NULL;
8539     OSErr _err;
8540     Str255 accessKeyType;
8541     long flags;
8542     Handle accessKey;
8543 #ifndef QTRegisterAccessKey
8544     PyMac_PRECHECK(QTRegisterAccessKey);
8545 #endif
8546     if (!PyArg_ParseTuple(_args, "O&lO&",
8547                           PyMac_GetStr255, accessKeyType,
8548                           &flags,
8549                           ResObj_Convert, &accessKey))
8550         return NULL;
8551     _err = QTRegisterAccessKey(accessKeyType,
8552                                flags,
8553                                accessKey);
8554     if (_err != noErr) return PyMac_Error(_err);
8555     Py_INCREF(Py_None);
8556     _res = Py_None;
8557     return _res;
8558 }
8559
8560 static PyObject *Qt_QTUnregisterAccessKey(PyObject *_self, PyObject *_args)
8561 {
8562     PyObject *_res = NULL;
8563     OSErr _err;
8564     Str255 accessKeyType;
8565     long flags;
8566     Handle accessKey;
8567 #ifndef QTUnregisterAccessKey
8568     PyMac_PRECHECK(QTUnregisterAccessKey);
8569 #endif
8570     if (!PyArg_ParseTuple(_args, "O&lO&",
8571                           PyMac_GetStr255, accessKeyType,
8572                           &flags,
8573                           ResObj_Convert, &accessKey))
8574         return NULL;
8575     _err = QTUnregisterAccessKey(accessKeyType,
8576                                  flags,
8577                                  accessKey);
8578     if (_err != noErr) return PyMac_Error(_err);
8579     Py_INCREF(Py_None);
8580     _res = Py_None;
8581     return _res;
8582 }
8583
8584 static PyObject *Qt_QTGetSupportedRestrictions(PyObject *_self, PyObject *_args)
8585 {
8586     PyObject *_res = NULL;
8587     OSErr _err;
8588     OSType inRestrictionClass;
8589     UInt32 outRestrictionIDs;
8590 #ifndef QTGetSupportedRestrictions
8591     PyMac_PRECHECK(QTGetSupportedRestrictions);
8592 #endif
8593     if (!PyArg_ParseTuple(_args, "O&",
8594                           PyMac_GetOSType, &inRestrictionClass))
8595         return NULL;
8596     _err = QTGetSupportedRestrictions(inRestrictionClass,
8597                                       &outRestrictionIDs);
8598     if (_err != noErr) return PyMac_Error(_err);
8599     _res = Py_BuildValue("l",
8600                          outRestrictionIDs);
8601     return _res;
8602 }
8603
8604 static PyObject *Qt_QTTextToNativeText(PyObject *_self, PyObject *_args)
8605 {
8606     PyObject *_res = NULL;
8607     OSErr _err;
8608     Handle theText;
8609     long encoding;
8610     long flags;
8611 #ifndef QTTextToNativeText
8612     PyMac_PRECHECK(QTTextToNativeText);
8613 #endif
8614     if (!PyArg_ParseTuple(_args, "O&ll",
8615                           ResObj_Convert, &theText,
8616                           &encoding,
8617                           &flags))
8618         return NULL;
8619     _err = QTTextToNativeText(theText,
8620                               encoding,
8621                               flags);
8622     if (_err != noErr) return PyMac_Error(_err);
8623     Py_INCREF(Py_None);
8624     _res = Py_None;
8625     return _res;
8626 }
8627
8628 static PyObject *Qt_VideoMediaResetStatistics(PyObject *_self, PyObject *_args)
8629 {
8630     PyObject *_res = NULL;
8631     ComponentResult _rv;
8632     MediaHandler mh;
8633 #ifndef VideoMediaResetStatistics
8634     PyMac_PRECHECK(VideoMediaResetStatistics);
8635 #endif
8636     if (!PyArg_ParseTuple(_args, "O&",
8637                           CmpInstObj_Convert, &mh))
8638         return NULL;
8639     _rv = VideoMediaResetStatistics(mh);
8640     _res = Py_BuildValue("l",
8641                          _rv);
8642     return _res;
8643 }
8644
8645 static PyObject *Qt_VideoMediaGetStatistics(PyObject *_self, PyObject *_args)
8646 {
8647     PyObject *_res = NULL;
8648     ComponentResult _rv;
8649     MediaHandler mh;
8650 #ifndef VideoMediaGetStatistics
8651     PyMac_PRECHECK(VideoMediaGetStatistics);
8652 #endif
8653     if (!PyArg_ParseTuple(_args, "O&",
8654                           CmpInstObj_Convert, &mh))
8655         return NULL;
8656     _rv = VideoMediaGetStatistics(mh);
8657     _res = Py_BuildValue("l",
8658                          _rv);
8659     return _res;
8660 }
8661
8662 static PyObject *Qt_VideoMediaGetStallCount(PyObject *_self, PyObject *_args)
8663 {
8664     PyObject *_res = NULL;
8665     ComponentResult _rv;
8666     MediaHandler mh;
8667     unsigned long stalls;
8668 #ifndef VideoMediaGetStallCount
8669     PyMac_PRECHECK(VideoMediaGetStallCount);
8670 #endif
8671     if (!PyArg_ParseTuple(_args, "O&",
8672                           CmpInstObj_Convert, &mh))
8673         return NULL;
8674     _rv = VideoMediaGetStallCount(mh,
8675                                   &stalls);
8676     _res = Py_BuildValue("ll",
8677                          _rv,
8678                          stalls);
8679     return _res;
8680 }
8681
8682 static PyObject *Qt_VideoMediaSetCodecParameter(PyObject *_self, PyObject *_args)
8683 {
8684     PyObject *_res = NULL;
8685     ComponentResult _rv;
8686     MediaHandler mh;
8687     CodecType cType;
8688     OSType parameterID;
8689     long parameterChangeSeed;
8690     void * dataPtr;
8691     long dataSize;
8692 #ifndef VideoMediaSetCodecParameter
8693     PyMac_PRECHECK(VideoMediaSetCodecParameter);
8694 #endif
8695     if (!PyArg_ParseTuple(_args, "O&O&O&lsl",
8696                           CmpInstObj_Convert, &mh,
8697                           PyMac_GetOSType, &cType,
8698                           PyMac_GetOSType, &parameterID,
8699                           &parameterChangeSeed,
8700                           &dataPtr,
8701                           &dataSize))
8702         return NULL;
8703     _rv = VideoMediaSetCodecParameter(mh,
8704                                       cType,
8705                                       parameterID,
8706                                       parameterChangeSeed,
8707                                       dataPtr,
8708                                       dataSize);
8709     _res = Py_BuildValue("l",
8710                          _rv);
8711     return _res;
8712 }
8713
8714 static PyObject *Qt_VideoMediaGetCodecParameter(PyObject *_self, PyObject *_args)
8715 {
8716     PyObject *_res = NULL;
8717     ComponentResult _rv;
8718     MediaHandler mh;
8719     CodecType cType;
8720     OSType parameterID;
8721     Handle outParameterData;
8722 #ifndef VideoMediaGetCodecParameter
8723     PyMac_PRECHECK(VideoMediaGetCodecParameter);
8724 #endif
8725     if (!PyArg_ParseTuple(_args, "O&O&O&O&",
8726                           CmpInstObj_Convert, &mh,
8727                           PyMac_GetOSType, &cType,
8728                           PyMac_GetOSType, &parameterID,
8729                           ResObj_Convert, &outParameterData))
8730         return NULL;
8731     _rv = VideoMediaGetCodecParameter(mh,
8732                                       cType,
8733                                       parameterID,
8734                                       outParameterData);
8735     _res = Py_BuildValue("l",
8736                          _rv);
8737     return _res;
8738 }
8739
8740 static PyObject *Qt_TextMediaAddTextSample(PyObject *_self, PyObject *_args)
8741 {
8742     PyObject *_res = NULL;
8743     ComponentResult _rv;
8744     MediaHandler mh;
8745     Ptr text;
8746     unsigned long size;
8747     short fontNumber;
8748     short fontSize;
8749     Style textFace;
8750     RGBColor textColor;
8751     RGBColor backColor;
8752     short textJustification;
8753     Rect textBox;
8754     long displayFlags;
8755     TimeValue scrollDelay;
8756     short hiliteStart;
8757     short hiliteEnd;
8758     RGBColor rgbHiliteColor;
8759     TimeValue duration;
8760     TimeValue sampleTime;
8761 #ifndef TextMediaAddTextSample
8762     PyMac_PRECHECK(TextMediaAddTextSample);
8763 #endif
8764     if (!PyArg_ParseTuple(_args, "O&slhhbhllhhl",
8765                           CmpInstObj_Convert, &mh,
8766                           &text,
8767                           &size,
8768                           &fontNumber,
8769                           &fontSize,
8770                           &textFace,
8771                           &textJustification,
8772                           &displayFlags,
8773                           &scrollDelay,
8774                           &hiliteStart,
8775                           &hiliteEnd,
8776                           &duration))
8777         return NULL;
8778     _rv = TextMediaAddTextSample(mh,
8779                                  text,
8780                                  size,
8781                                  fontNumber,
8782                                  fontSize,
8783                                  textFace,
8784                                  &textColor,
8785                                  &backColor,
8786                                  textJustification,
8787                                  &textBox,
8788                                  displayFlags,
8789                                  scrollDelay,
8790                                  hiliteStart,
8791                                  hiliteEnd,
8792                                  &rgbHiliteColor,
8793                                  duration,
8794                                  &sampleTime);
8795     _res = Py_BuildValue("lO&O&O&O&l",
8796                          _rv,
8797                          QdRGB_New, &textColor,
8798                          QdRGB_New, &backColor,
8799                          PyMac_BuildRect, &textBox,
8800                          QdRGB_New, &rgbHiliteColor,
8801                          sampleTime);
8802     return _res;
8803 }
8804
8805 static PyObject *Qt_TextMediaAddTESample(PyObject *_self, PyObject *_args)
8806 {
8807     PyObject *_res = NULL;
8808     ComponentResult _rv;
8809     MediaHandler mh;
8810     TEHandle hTE;
8811     RGBColor backColor;
8812     short textJustification;
8813     Rect textBox;
8814     long displayFlags;
8815     TimeValue scrollDelay;
8816     short hiliteStart;
8817     short hiliteEnd;
8818     RGBColor rgbHiliteColor;
8819     TimeValue duration;
8820     TimeValue sampleTime;
8821 #ifndef TextMediaAddTESample
8822     PyMac_PRECHECK(TextMediaAddTESample);
8823 #endif
8824     if (!PyArg_ParseTuple(_args, "O&O&hllhhl",
8825                           CmpInstObj_Convert, &mh,
8826                           ResObj_Convert, &hTE,
8827                           &textJustification,
8828                           &displayFlags,
8829                           &scrollDelay,
8830                           &hiliteStart,
8831                           &hiliteEnd,
8832                           &duration))
8833         return NULL;
8834     _rv = TextMediaAddTESample(mh,
8835                                hTE,
8836                                &backColor,
8837                                textJustification,
8838                                &textBox,
8839                                displayFlags,
8840                                scrollDelay,
8841                                hiliteStart,
8842                                hiliteEnd,
8843                                &rgbHiliteColor,
8844                                duration,
8845                                &sampleTime);
8846     _res = Py_BuildValue("lO&O&O&l",
8847                          _rv,
8848                          QdRGB_New, &backColor,
8849                          PyMac_BuildRect, &textBox,
8850                          QdRGB_New, &rgbHiliteColor,
8851                          sampleTime);
8852     return _res;
8853 }
8854
8855 static PyObject *Qt_TextMediaAddHiliteSample(PyObject *_self, PyObject *_args)
8856 {
8857     PyObject *_res = NULL;
8858     ComponentResult _rv;
8859     MediaHandler mh;
8860     short hiliteStart;
8861     short hiliteEnd;
8862     RGBColor rgbHiliteColor;
8863     TimeValue duration;
8864     TimeValue sampleTime;
8865 #ifndef TextMediaAddHiliteSample
8866     PyMac_PRECHECK(TextMediaAddHiliteSample);
8867 #endif
8868     if (!PyArg_ParseTuple(_args, "O&hhl",
8869                           CmpInstObj_Convert, &mh,
8870                           &hiliteStart,
8871                           &hiliteEnd,
8872                           &duration))
8873         return NULL;
8874     _rv = TextMediaAddHiliteSample(mh,
8875                                    hiliteStart,
8876                                    hiliteEnd,
8877                                    &rgbHiliteColor,
8878                                    duration,
8879                                    &sampleTime);
8880     _res = Py_BuildValue("lO&l",
8881                          _rv,
8882                          QdRGB_New, &rgbHiliteColor,
8883                          sampleTime);
8884     return _res;
8885 }
8886
8887 static PyObject *Qt_TextMediaDrawRaw(PyObject *_self, PyObject *_args)
8888 {
8889     PyObject *_res = NULL;
8890     ComponentResult _rv;
8891     MediaHandler mh;
8892     GWorldPtr gw;
8893     GDHandle gd;
8894     void * data;
8895     long dataSize;
8896     TextDescriptionHandle tdh;
8897 #ifndef TextMediaDrawRaw
8898     PyMac_PRECHECK(TextMediaDrawRaw);
8899 #endif
8900     if (!PyArg_ParseTuple(_args, "O&O&O&slO&",
8901                           CmpInstObj_Convert, &mh,
8902                           GWorldObj_Convert, &gw,
8903                           OptResObj_Convert, &gd,
8904                           &data,
8905                           &dataSize,
8906                           ResObj_Convert, &tdh))
8907         return NULL;
8908     _rv = TextMediaDrawRaw(mh,
8909                            gw,
8910                            gd,
8911                            data,
8912                            dataSize,
8913                            tdh);
8914     _res = Py_BuildValue("l",
8915                          _rv);
8916     return _res;
8917 }
8918
8919 static PyObject *Qt_TextMediaSetTextProperty(PyObject *_self, PyObject *_args)
8920 {
8921     PyObject *_res = NULL;
8922     ComponentResult _rv;
8923     MediaHandler mh;
8924     TimeValue atMediaTime;
8925     long propertyType;
8926     void * data;
8927     long dataSize;
8928 #ifndef TextMediaSetTextProperty
8929     PyMac_PRECHECK(TextMediaSetTextProperty);
8930 #endif
8931     if (!PyArg_ParseTuple(_args, "O&llsl",
8932                           CmpInstObj_Convert, &mh,
8933                           &atMediaTime,
8934                           &propertyType,
8935                           &data,
8936                           &dataSize))
8937         return NULL;
8938     _rv = TextMediaSetTextProperty(mh,
8939                                    atMediaTime,
8940                                    propertyType,
8941                                    data,
8942                                    dataSize);
8943     _res = Py_BuildValue("l",
8944                          _rv);
8945     return _res;
8946 }
8947
8948 static PyObject *Qt_TextMediaRawSetup(PyObject *_self, PyObject *_args)
8949 {
8950     PyObject *_res = NULL;
8951     ComponentResult _rv;
8952     MediaHandler mh;
8953     GWorldPtr gw;
8954     GDHandle gd;
8955     void * data;
8956     long dataSize;
8957     TextDescriptionHandle tdh;
8958     TimeValue sampleDuration;
8959 #ifndef TextMediaRawSetup
8960     PyMac_PRECHECK(TextMediaRawSetup);
8961 #endif
8962     if (!PyArg_ParseTuple(_args, "O&O&O&slO&l",
8963                           CmpInstObj_Convert, &mh,
8964                           GWorldObj_Convert, &gw,
8965                           OptResObj_Convert, &gd,
8966                           &data,
8967                           &dataSize,
8968                           ResObj_Convert, &tdh,
8969                           &sampleDuration))
8970         return NULL;
8971     _rv = TextMediaRawSetup(mh,
8972                             gw,
8973                             gd,
8974                             data,
8975                             dataSize,
8976                             tdh,
8977                             sampleDuration);
8978     _res = Py_BuildValue("l",
8979                          _rv);
8980     return _res;
8981 }
8982
8983 static PyObject *Qt_TextMediaRawIdle(PyObject *_self, PyObject *_args)
8984 {
8985     PyObject *_res = NULL;
8986     ComponentResult _rv;
8987     MediaHandler mh;
8988     GWorldPtr gw;
8989     GDHandle gd;
8990     TimeValue sampleTime;
8991     long flagsIn;
8992     long flagsOut;
8993 #ifndef TextMediaRawIdle
8994     PyMac_PRECHECK(TextMediaRawIdle);
8995 #endif
8996     if (!PyArg_ParseTuple(_args, "O&O&O&ll",
8997                           CmpInstObj_Convert, &mh,
8998                           GWorldObj_Convert, &gw,
8999                           OptResObj_Convert, &gd,
9000                           &sampleTime,
9001                           &flagsIn))
9002         return NULL;
9003     _rv = TextMediaRawIdle(mh,
9004                            gw,
9005                            gd,
9006                            sampleTime,
9007                            flagsIn,
9008                            &flagsOut);
9009     _res = Py_BuildValue("ll",
9010                          _rv,
9011                          flagsOut);
9012     return _res;
9013 }
9014
9015 static PyObject *Qt_TextMediaGetTextProperty(PyObject *_self, PyObject *_args)
9016 {
9017     PyObject *_res = NULL;
9018     ComponentResult _rv;
9019     MediaHandler mh;
9020     TimeValue atMediaTime;
9021     long propertyType;
9022     void * data;
9023     long dataSize;
9024 #ifndef TextMediaGetTextProperty
9025     PyMac_PRECHECK(TextMediaGetTextProperty);
9026 #endif
9027     if (!PyArg_ParseTuple(_args, "O&llsl",
9028                           CmpInstObj_Convert, &mh,
9029                           &atMediaTime,
9030                           &propertyType,
9031                           &data,
9032                           &dataSize))
9033         return NULL;
9034     _rv = TextMediaGetTextProperty(mh,
9035                                    atMediaTime,
9036                                    propertyType,
9037                                    data,
9038                                    dataSize);
9039     _res = Py_BuildValue("l",
9040                          _rv);
9041     return _res;
9042 }
9043
9044 static PyObject *Qt_TextMediaFindNextText(PyObject *_self, PyObject *_args)
9045 {
9046     PyObject *_res = NULL;
9047     ComponentResult _rv;
9048     MediaHandler mh;
9049     Ptr text;
9050     long size;
9051     short findFlags;
9052     TimeValue startTime;
9053     TimeValue foundTime;
9054     TimeValue foundDuration;
9055     long offset;
9056 #ifndef TextMediaFindNextText
9057     PyMac_PRECHECK(TextMediaFindNextText);
9058 #endif
9059     if (!PyArg_ParseTuple(_args, "O&slhl",
9060                           CmpInstObj_Convert, &mh,
9061                           &text,
9062                           &size,
9063                           &findFlags,
9064                           &startTime))
9065         return NULL;
9066     _rv = TextMediaFindNextText(mh,
9067                                 text,
9068                                 size,
9069                                 findFlags,
9070                                 startTime,
9071                                 &foundTime,
9072                                 &foundDuration,
9073                                 &offset);
9074     _res = Py_BuildValue("llll",
9075                          _rv,
9076                          foundTime,
9077                          foundDuration,
9078                          offset);
9079     return _res;
9080 }
9081
9082 static PyObject *Qt_TextMediaHiliteTextSample(PyObject *_self, PyObject *_args)
9083 {
9084     PyObject *_res = NULL;
9085     ComponentResult _rv;
9086     MediaHandler mh;
9087     TimeValue sampleTime;
9088     short hiliteStart;
9089     short hiliteEnd;
9090     RGBColor rgbHiliteColor;
9091 #ifndef TextMediaHiliteTextSample
9092     PyMac_PRECHECK(TextMediaHiliteTextSample);
9093 #endif
9094     if (!PyArg_ParseTuple(_args, "O&lhh",
9095                           CmpInstObj_Convert, &mh,
9096                           &sampleTime,
9097                           &hiliteStart,
9098                           &hiliteEnd))
9099         return NULL;
9100     _rv = TextMediaHiliteTextSample(mh,
9101                                     sampleTime,
9102                                     hiliteStart,
9103                                     hiliteEnd,
9104                                     &rgbHiliteColor);
9105     _res = Py_BuildValue("lO&",
9106                          _rv,
9107                          QdRGB_New, &rgbHiliteColor);
9108     return _res;
9109 }
9110
9111 static PyObject *Qt_TextMediaSetTextSampleData(PyObject *_self, PyObject *_args)
9112 {
9113     PyObject *_res = NULL;
9114     ComponentResult _rv;
9115     MediaHandler mh;
9116     void * data;
9117     OSType dataType;
9118 #ifndef TextMediaSetTextSampleData
9119     PyMac_PRECHECK(TextMediaSetTextSampleData);
9120 #endif
9121     if (!PyArg_ParseTuple(_args, "O&sO&",
9122                           CmpInstObj_Convert, &mh,
9123                           &data,
9124                           PyMac_GetOSType, &dataType))
9125         return NULL;
9126     _rv = TextMediaSetTextSampleData(mh,
9127                                      data,
9128                                      dataType);
9129     _res = Py_BuildValue("l",
9130                          _rv);
9131     return _res;
9132 }
9133
9134 static PyObject *Qt_SpriteMediaSetProperty(PyObject *_self, PyObject *_args)
9135 {
9136     PyObject *_res = NULL;
9137     ComponentResult _rv;
9138     MediaHandler mh;
9139     short spriteIndex;
9140     long propertyType;
9141     void * propertyValue;
9142 #ifndef SpriteMediaSetProperty
9143     PyMac_PRECHECK(SpriteMediaSetProperty);
9144 #endif
9145     if (!PyArg_ParseTuple(_args, "O&hls",
9146                           CmpInstObj_Convert, &mh,
9147                           &spriteIndex,
9148                           &propertyType,
9149                           &propertyValue))
9150         return NULL;
9151     _rv = SpriteMediaSetProperty(mh,
9152                                  spriteIndex,
9153                                  propertyType,
9154                                  propertyValue);
9155     _res = Py_BuildValue("l",
9156                          _rv);
9157     return _res;
9158 }
9159
9160 static PyObject *Qt_SpriteMediaGetProperty(PyObject *_self, PyObject *_args)
9161 {
9162     PyObject *_res = NULL;
9163     ComponentResult _rv;
9164     MediaHandler mh;
9165     short spriteIndex;
9166     long propertyType;
9167     void * propertyValue;
9168 #ifndef SpriteMediaGetProperty
9169     PyMac_PRECHECK(SpriteMediaGetProperty);
9170 #endif
9171     if (!PyArg_ParseTuple(_args, "O&hls",
9172                           CmpInstObj_Convert, &mh,
9173                           &spriteIndex,
9174                           &propertyType,
9175                           &propertyValue))
9176         return NULL;
9177     _rv = SpriteMediaGetProperty(mh,
9178                                  spriteIndex,
9179                                  propertyType,
9180                                  propertyValue);
9181     _res = Py_BuildValue("l",
9182                          _rv);
9183     return _res;
9184 }
9185
9186 static PyObject *Qt_SpriteMediaHitTestSprites(PyObject *_self, PyObject *_args)
9187 {
9188     PyObject *_res = NULL;
9189     ComponentResult _rv;
9190     MediaHandler mh;
9191     long flags;
9192     Point loc;
9193     short spriteHitIndex;
9194 #ifndef SpriteMediaHitTestSprites
9195     PyMac_PRECHECK(SpriteMediaHitTestSprites);
9196 #endif
9197     if (!PyArg_ParseTuple(_args, "O&lO&",
9198                           CmpInstObj_Convert, &mh,
9199                           &flags,
9200                           PyMac_GetPoint, &loc))
9201         return NULL;
9202     _rv = SpriteMediaHitTestSprites(mh,
9203                                     flags,
9204                                     loc,
9205                                     &spriteHitIndex);
9206     _res = Py_BuildValue("lh",
9207                          _rv,
9208                          spriteHitIndex);
9209     return _res;
9210 }
9211
9212 static PyObject *Qt_SpriteMediaCountSprites(PyObject *_self, PyObject *_args)
9213 {
9214     PyObject *_res = NULL;
9215     ComponentResult _rv;
9216     MediaHandler mh;
9217     short numSprites;
9218 #ifndef SpriteMediaCountSprites
9219     PyMac_PRECHECK(SpriteMediaCountSprites);
9220 #endif
9221     if (!PyArg_ParseTuple(_args, "O&",
9222                           CmpInstObj_Convert, &mh))
9223         return NULL;
9224     _rv = SpriteMediaCountSprites(mh,
9225                                   &numSprites);
9226     _res = Py_BuildValue("lh",
9227                          _rv,
9228                          numSprites);
9229     return _res;
9230 }
9231
9232 static PyObject *Qt_SpriteMediaCountImages(PyObject *_self, PyObject *_args)
9233 {
9234     PyObject *_res = NULL;
9235     ComponentResult _rv;
9236     MediaHandler mh;
9237     short numImages;
9238 #ifndef SpriteMediaCountImages
9239     PyMac_PRECHECK(SpriteMediaCountImages);
9240 #endif
9241     if (!PyArg_ParseTuple(_args, "O&",
9242                           CmpInstObj_Convert, &mh))
9243         return NULL;
9244     _rv = SpriteMediaCountImages(mh,
9245                                  &numImages);
9246     _res = Py_BuildValue("lh",
9247                          _rv,
9248                          numImages);
9249     return _res;
9250 }
9251
9252 static PyObject *Qt_SpriteMediaGetIndImageDescription(PyObject *_self, PyObject *_args)
9253 {
9254     PyObject *_res = NULL;
9255     ComponentResult _rv;
9256     MediaHandler mh;
9257     short imageIndex;
9258     ImageDescriptionHandle imageDescription;
9259 #ifndef SpriteMediaGetIndImageDescription
9260     PyMac_PRECHECK(SpriteMediaGetIndImageDescription);
9261 #endif
9262     if (!PyArg_ParseTuple(_args, "O&hO&",
9263                           CmpInstObj_Convert, &mh,
9264                           &imageIndex,
9265                           ResObj_Convert, &imageDescription))
9266         return NULL;
9267     _rv = SpriteMediaGetIndImageDescription(mh,
9268                                             imageIndex,
9269                                             imageDescription);
9270     _res = Py_BuildValue("l",
9271                          _rv);
9272     return _res;
9273 }
9274
9275 static PyObject *Qt_SpriteMediaGetDisplayedSampleNumber(PyObject *_self, PyObject *_args)
9276 {
9277     PyObject *_res = NULL;
9278     ComponentResult _rv;
9279     MediaHandler mh;
9280     long sampleNum;
9281 #ifndef SpriteMediaGetDisplayedSampleNumber
9282     PyMac_PRECHECK(SpriteMediaGetDisplayedSampleNumber);
9283 #endif
9284     if (!PyArg_ParseTuple(_args, "O&",
9285                           CmpInstObj_Convert, &mh))
9286         return NULL;
9287     _rv = SpriteMediaGetDisplayedSampleNumber(mh,
9288                                               &sampleNum);
9289     _res = Py_BuildValue("ll",
9290                          _rv,
9291                          sampleNum);
9292     return _res;
9293 }
9294
9295 static PyObject *Qt_SpriteMediaGetSpriteName(PyObject *_self, PyObject *_args)
9296 {
9297     PyObject *_res = NULL;
9298     ComponentResult _rv;
9299     MediaHandler mh;
9300     QTAtomID spriteID;
9301     Str255 spriteName;
9302 #ifndef SpriteMediaGetSpriteName
9303     PyMac_PRECHECK(SpriteMediaGetSpriteName);
9304 #endif
9305     if (!PyArg_ParseTuple(_args, "O&lO&",
9306                           CmpInstObj_Convert, &mh,
9307                           &spriteID,
9308                           PyMac_GetStr255, spriteName))
9309         return NULL;
9310     _rv = SpriteMediaGetSpriteName(mh,
9311                                    spriteID,
9312                                    spriteName);
9313     _res = Py_BuildValue("l",
9314                          _rv);
9315     return _res;
9316 }
9317
9318 static PyObject *Qt_SpriteMediaGetImageName(PyObject *_self, PyObject *_args)
9319 {
9320     PyObject *_res = NULL;
9321     ComponentResult _rv;
9322     MediaHandler mh;
9323     short imageIndex;
9324     Str255 imageName;
9325 #ifndef SpriteMediaGetImageName
9326     PyMac_PRECHECK(SpriteMediaGetImageName);
9327 #endif
9328     if (!PyArg_ParseTuple(_args, "O&hO&",
9329                           CmpInstObj_Convert, &mh,
9330                           &imageIndex,
9331                           PyMac_GetStr255, imageName))
9332         return NULL;
9333     _rv = SpriteMediaGetImageName(mh,
9334                                   imageIndex,
9335                                   imageName);
9336     _res = Py_BuildValue("l",
9337                          _rv);
9338     return _res;
9339 }
9340
9341 static PyObject *Qt_SpriteMediaSetSpriteProperty(PyObject *_self, PyObject *_args)
9342 {
9343     PyObject *_res = NULL;
9344     ComponentResult _rv;
9345     MediaHandler mh;
9346     QTAtomID spriteID;
9347     long propertyType;
9348     void * propertyValue;
9349 #ifndef SpriteMediaSetSpriteProperty
9350     PyMac_PRECHECK(SpriteMediaSetSpriteProperty);
9351 #endif
9352     if (!PyArg_ParseTuple(_args, "O&lls",
9353                           CmpInstObj_Convert, &mh,
9354                           &spriteID,
9355                           &propertyType,
9356                           &propertyValue))
9357         return NULL;
9358     _rv = SpriteMediaSetSpriteProperty(mh,
9359                                        spriteID,
9360                                        propertyType,
9361                                        propertyValue);
9362     _res = Py_BuildValue("l",
9363                          _rv);
9364     return _res;
9365 }
9366
9367 static PyObject *Qt_SpriteMediaGetSpriteProperty(PyObject *_self, PyObject *_args)
9368 {
9369     PyObject *_res = NULL;
9370     ComponentResult _rv;
9371     MediaHandler mh;
9372     QTAtomID spriteID;
9373     long propertyType;
9374     void * propertyValue;
9375 #ifndef SpriteMediaGetSpriteProperty
9376     PyMac_PRECHECK(SpriteMediaGetSpriteProperty);
9377 #endif
9378     if (!PyArg_ParseTuple(_args, "O&lls",
9379                           CmpInstObj_Convert, &mh,
9380                           &spriteID,
9381                           &propertyType,
9382                           &propertyValue))
9383         return NULL;
9384     _rv = SpriteMediaGetSpriteProperty(mh,
9385                                        spriteID,
9386                                        propertyType,
9387                                        propertyValue);
9388     _res = Py_BuildValue("l",
9389                          _rv);
9390     return _res;
9391 }
9392
9393 static PyObject *Qt_SpriteMediaHitTestAllSprites(PyObject *_self, PyObject *_args)
9394 {
9395     PyObject *_res = NULL;
9396     ComponentResult _rv;
9397     MediaHandler mh;
9398     long flags;
9399     Point loc;
9400     QTAtomID spriteHitID;
9401 #ifndef SpriteMediaHitTestAllSprites
9402     PyMac_PRECHECK(SpriteMediaHitTestAllSprites);
9403 #endif
9404     if (!PyArg_ParseTuple(_args, "O&lO&",
9405                           CmpInstObj_Convert, &mh,
9406                           &flags,
9407                           PyMac_GetPoint, &loc))
9408         return NULL;
9409     _rv = SpriteMediaHitTestAllSprites(mh,
9410                                        flags,
9411                                        loc,
9412                                        &spriteHitID);
9413     _res = Py_BuildValue("ll",
9414                          _rv,
9415                          spriteHitID);
9416     return _res;
9417 }
9418
9419 static PyObject *Qt_SpriteMediaHitTestOneSprite(PyObject *_self, PyObject *_args)
9420 {
9421     PyObject *_res = NULL;
9422     ComponentResult _rv;
9423     MediaHandler mh;
9424     QTAtomID spriteID;
9425     long flags;
9426     Point loc;
9427     Boolean wasHit;
9428 #ifndef SpriteMediaHitTestOneSprite
9429     PyMac_PRECHECK(SpriteMediaHitTestOneSprite);
9430 #endif
9431     if (!PyArg_ParseTuple(_args, "O&llO&",
9432                           CmpInstObj_Convert, &mh,
9433                           &spriteID,
9434                           &flags,
9435                           PyMac_GetPoint, &loc))
9436         return NULL;
9437     _rv = SpriteMediaHitTestOneSprite(mh,
9438                                       spriteID,
9439                                       flags,
9440                                       loc,
9441                                       &wasHit);
9442     _res = Py_BuildValue("lb",
9443                          _rv,
9444                          wasHit);
9445     return _res;
9446 }
9447
9448 static PyObject *Qt_SpriteMediaSpriteIndexToID(PyObject *_self, PyObject *_args)
9449 {
9450     PyObject *_res = NULL;
9451     ComponentResult _rv;
9452     MediaHandler mh;
9453     short spriteIndex;
9454     QTAtomID spriteID;
9455 #ifndef SpriteMediaSpriteIndexToID
9456     PyMac_PRECHECK(SpriteMediaSpriteIndexToID);
9457 #endif
9458     if (!PyArg_ParseTuple(_args, "O&h",
9459                           CmpInstObj_Convert, &mh,
9460                           &spriteIndex))
9461         return NULL;
9462     _rv = SpriteMediaSpriteIndexToID(mh,
9463                                      spriteIndex,
9464                                      &spriteID);
9465     _res = Py_BuildValue("ll",
9466                          _rv,
9467                          spriteID);
9468     return _res;
9469 }
9470
9471 static PyObject *Qt_SpriteMediaSpriteIDToIndex(PyObject *_self, PyObject *_args)
9472 {
9473     PyObject *_res = NULL;
9474     ComponentResult _rv;
9475     MediaHandler mh;
9476     QTAtomID spriteID;
9477     short spriteIndex;
9478 #ifndef SpriteMediaSpriteIDToIndex
9479     PyMac_PRECHECK(SpriteMediaSpriteIDToIndex);
9480 #endif
9481     if (!PyArg_ParseTuple(_args, "O&l",
9482                           CmpInstObj_Convert, &mh,
9483                           &spriteID))
9484         return NULL;
9485     _rv = SpriteMediaSpriteIDToIndex(mh,
9486                                      spriteID,
9487                                      &spriteIndex);
9488     _res = Py_BuildValue("lh",
9489                          _rv,
9490                          spriteIndex);
9491     return _res;
9492 }
9493
9494 static PyObject *Qt_SpriteMediaSetActionVariable(PyObject *_self, PyObject *_args)
9495 {
9496     PyObject *_res = NULL;
9497     ComponentResult _rv;
9498     MediaHandler mh;
9499     QTAtomID variableID;
9500     float value;
9501 #ifndef SpriteMediaSetActionVariable
9502     PyMac_PRECHECK(SpriteMediaSetActionVariable);
9503 #endif
9504     if (!PyArg_ParseTuple(_args, "O&lf",
9505                           CmpInstObj_Convert, &mh,
9506                           &variableID,
9507                           &value))
9508         return NULL;
9509     _rv = SpriteMediaSetActionVariable(mh,
9510                                        variableID,
9511                                        &value);
9512     _res = Py_BuildValue("l",
9513                          _rv);
9514     return _res;
9515 }
9516
9517 static PyObject *Qt_SpriteMediaGetActionVariable(PyObject *_self, PyObject *_args)
9518 {
9519     PyObject *_res = NULL;
9520     ComponentResult _rv;
9521     MediaHandler mh;
9522     QTAtomID variableID;
9523     float value;
9524 #ifndef SpriteMediaGetActionVariable
9525     PyMac_PRECHECK(SpriteMediaGetActionVariable);
9526 #endif
9527     if (!PyArg_ParseTuple(_args, "O&l",
9528                           CmpInstObj_Convert, &mh,
9529                           &variableID))
9530         return NULL;
9531     _rv = SpriteMediaGetActionVariable(mh,
9532                                        variableID,
9533                                        &value);
9534     _res = Py_BuildValue("lf",
9535                          _rv,
9536                          value);
9537     return _res;
9538 }
9539
9540 static PyObject *Qt_SpriteMediaDisposeSprite(PyObject *_self, PyObject *_args)
9541 {
9542     PyObject *_res = NULL;
9543     ComponentResult _rv;
9544     MediaHandler mh;
9545     QTAtomID spriteID;
9546 #ifndef SpriteMediaDisposeSprite
9547     PyMac_PRECHECK(SpriteMediaDisposeSprite);
9548 #endif
9549     if (!PyArg_ParseTuple(_args, "O&l",
9550                           CmpInstObj_Convert, &mh,
9551                           &spriteID))
9552         return NULL;
9553     _rv = SpriteMediaDisposeSprite(mh,
9554                                    spriteID);
9555     _res = Py_BuildValue("l",
9556                          _rv);
9557     return _res;
9558 }
9559
9560 static PyObject *Qt_SpriteMediaSetActionVariableToString(PyObject *_self, PyObject *_args)
9561 {
9562     PyObject *_res = NULL;
9563     ComponentResult _rv;
9564     MediaHandler mh;
9565     QTAtomID variableID;
9566     Ptr theCString;
9567 #ifndef SpriteMediaSetActionVariableToString
9568     PyMac_PRECHECK(SpriteMediaSetActionVariableToString);
9569 #endif
9570     if (!PyArg_ParseTuple(_args, "O&ls",
9571                           CmpInstObj_Convert, &mh,
9572                           &variableID,
9573                           &theCString))
9574         return NULL;
9575     _rv = SpriteMediaSetActionVariableToString(mh,
9576                                                variableID,
9577                                                theCString);
9578     _res = Py_BuildValue("l",
9579                          _rv);
9580     return _res;
9581 }
9582
9583 static PyObject *Qt_SpriteMediaGetActionVariableAsString(PyObject *_self, PyObject *_args)
9584 {
9585     PyObject *_res = NULL;
9586     ComponentResult _rv;
9587     MediaHandler mh;
9588     QTAtomID variableID;
9589     Handle theCString;
9590 #ifndef SpriteMediaGetActionVariableAsString
9591     PyMac_PRECHECK(SpriteMediaGetActionVariableAsString);
9592 #endif
9593     if (!PyArg_ParseTuple(_args, "O&l",
9594                           CmpInstObj_Convert, &mh,
9595                           &variableID))
9596         return NULL;
9597     _rv = SpriteMediaGetActionVariableAsString(mh,
9598                                                variableID,
9599                                                &theCString);
9600     _res = Py_BuildValue("lO&",
9601                          _rv,
9602                          ResObj_New, theCString);
9603     return _res;
9604 }
9605
9606 static PyObject *Qt_SpriteMediaNewImage(PyObject *_self, PyObject *_args)
9607 {
9608     PyObject *_res = NULL;
9609     ComponentResult _rv;
9610     MediaHandler mh;
9611     Handle dataRef;
9612     OSType dataRefType;
9613     QTAtomID desiredID;
9614 #ifndef SpriteMediaNewImage
9615     PyMac_PRECHECK(SpriteMediaNewImage);
9616 #endif
9617     if (!PyArg_ParseTuple(_args, "O&O&O&l",
9618                           CmpInstObj_Convert, &mh,
9619                           ResObj_Convert, &dataRef,
9620                           PyMac_GetOSType, &dataRefType,
9621                           &desiredID))
9622         return NULL;
9623     _rv = SpriteMediaNewImage(mh,
9624                               dataRef,
9625                               dataRefType,
9626                               desiredID);
9627     _res = Py_BuildValue("l",
9628                          _rv);
9629     return _res;
9630 }
9631
9632 static PyObject *Qt_SpriteMediaDisposeImage(PyObject *_self, PyObject *_args)
9633 {
9634     PyObject *_res = NULL;
9635     ComponentResult _rv;
9636     MediaHandler mh;
9637     short imageIndex;
9638 #ifndef SpriteMediaDisposeImage
9639     PyMac_PRECHECK(SpriteMediaDisposeImage);
9640 #endif
9641     if (!PyArg_ParseTuple(_args, "O&h",
9642                           CmpInstObj_Convert, &mh,
9643                           &imageIndex))
9644         return NULL;
9645     _rv = SpriteMediaDisposeImage(mh,
9646                                   imageIndex);
9647     _res = Py_BuildValue("l",
9648                          _rv);
9649     return _res;
9650 }
9651
9652 static PyObject *Qt_SpriteMediaImageIndexToID(PyObject *_self, PyObject *_args)
9653 {
9654     PyObject *_res = NULL;
9655     ComponentResult _rv;
9656     MediaHandler mh;
9657     short imageIndex;
9658     QTAtomID imageID;
9659 #ifndef SpriteMediaImageIndexToID
9660     PyMac_PRECHECK(SpriteMediaImageIndexToID);
9661 #endif
9662     if (!PyArg_ParseTuple(_args, "O&h",
9663                           CmpInstObj_Convert, &mh,
9664                           &imageIndex))
9665         return NULL;
9666     _rv = SpriteMediaImageIndexToID(mh,
9667                                     imageIndex,
9668                                     &imageID);
9669     _res = Py_BuildValue("ll",
9670                          _rv,
9671                          imageID);
9672     return _res;
9673 }
9674
9675 static PyObject *Qt_SpriteMediaImageIDToIndex(PyObject *_self, PyObject *_args)
9676 {
9677     PyObject *_res = NULL;
9678     ComponentResult _rv;
9679     MediaHandler mh;
9680     QTAtomID imageID;
9681     short imageIndex;
9682 #ifndef SpriteMediaImageIDToIndex
9683     PyMac_PRECHECK(SpriteMediaImageIDToIndex);
9684 #endif
9685     if (!PyArg_ParseTuple(_args, "O&l",
9686                           CmpInstObj_Convert, &mh,
9687                           &imageID))
9688         return NULL;
9689     _rv = SpriteMediaImageIDToIndex(mh,
9690                                     imageID,
9691                                     &imageIndex);
9692     _res = Py_BuildValue("lh",
9693                          _rv,
9694                          imageIndex);
9695     return _res;
9696 }
9697
9698 static PyObject *Qt_FlashMediaSetPan(PyObject *_self, PyObject *_args)
9699 {
9700     PyObject *_res = NULL;
9701     ComponentResult _rv;
9702     MediaHandler mh;
9703     short xPercent;
9704     short yPercent;
9705 #ifndef FlashMediaSetPan
9706     PyMac_PRECHECK(FlashMediaSetPan);
9707 #endif
9708     if (!PyArg_ParseTuple(_args, "O&hh",
9709                           CmpInstObj_Convert, &mh,
9710                           &xPercent,
9711                           &yPercent))
9712         return NULL;
9713     _rv = FlashMediaSetPan(mh,
9714                            xPercent,
9715                            yPercent);
9716     _res = Py_BuildValue("l",
9717                          _rv);
9718     return _res;
9719 }
9720
9721 static PyObject *Qt_FlashMediaSetZoom(PyObject *_self, PyObject *_args)
9722 {
9723     PyObject *_res = NULL;
9724     ComponentResult _rv;
9725     MediaHandler mh;
9726     short factor;
9727 #ifndef FlashMediaSetZoom
9728     PyMac_PRECHECK(FlashMediaSetZoom);
9729 #endif
9730     if (!PyArg_ParseTuple(_args, "O&h",
9731                           CmpInstObj_Convert, &mh,
9732                           &factor))
9733         return NULL;
9734     _rv = FlashMediaSetZoom(mh,
9735                             factor);
9736     _res = Py_BuildValue("l",
9737                          _rv);
9738     return _res;
9739 }
9740
9741 static PyObject *Qt_FlashMediaSetZoomRect(PyObject *_self, PyObject *_args)
9742 {
9743     PyObject *_res = NULL;
9744     ComponentResult _rv;
9745     MediaHandler mh;
9746     long left;
9747     long top;
9748     long right;
9749     long bottom;
9750 #ifndef FlashMediaSetZoomRect
9751     PyMac_PRECHECK(FlashMediaSetZoomRect);
9752 #endif
9753     if (!PyArg_ParseTuple(_args, "O&llll",
9754                           CmpInstObj_Convert, &mh,
9755                           &left,
9756                           &top,
9757                           &right,
9758                           &bottom))
9759         return NULL;
9760     _rv = FlashMediaSetZoomRect(mh,
9761                                 left,
9762                                 top,
9763                                 right,
9764                                 bottom);
9765     _res = Py_BuildValue("l",
9766                          _rv);
9767     return _res;
9768 }
9769
9770 static PyObject *Qt_FlashMediaGetRefConBounds(PyObject *_self, PyObject *_args)
9771 {
9772     PyObject *_res = NULL;
9773     ComponentResult _rv;
9774     MediaHandler mh;
9775     long refCon;
9776     long left;
9777     long top;
9778     long right;
9779     long bottom;
9780 #ifndef FlashMediaGetRefConBounds
9781     PyMac_PRECHECK(FlashMediaGetRefConBounds);
9782 #endif
9783     if (!PyArg_ParseTuple(_args, "O&l",
9784                           CmpInstObj_Convert, &mh,
9785                           &refCon))
9786         return NULL;
9787     _rv = FlashMediaGetRefConBounds(mh,
9788                                     refCon,
9789                                     &left,
9790                                     &top,
9791                                     &right,
9792                                     &bottom);
9793     _res = Py_BuildValue("lllll",
9794                          _rv,
9795                          left,
9796                          top,
9797                          right,
9798                          bottom);
9799     return _res;
9800 }
9801
9802 static PyObject *Qt_FlashMediaGetRefConID(PyObject *_self, PyObject *_args)
9803 {
9804     PyObject *_res = NULL;
9805     ComponentResult _rv;
9806     MediaHandler mh;
9807     long refCon;
9808     long refConID;
9809 #ifndef FlashMediaGetRefConID
9810     PyMac_PRECHECK(FlashMediaGetRefConID);
9811 #endif
9812     if (!PyArg_ParseTuple(_args, "O&l",
9813                           CmpInstObj_Convert, &mh,
9814                           &refCon))
9815         return NULL;
9816     _rv = FlashMediaGetRefConID(mh,
9817                                 refCon,
9818                                 &refConID);
9819     _res = Py_BuildValue("ll",
9820                          _rv,
9821                          refConID);
9822     return _res;
9823 }
9824
9825 static PyObject *Qt_FlashMediaIDToRefCon(PyObject *_self, PyObject *_args)
9826 {
9827     PyObject *_res = NULL;
9828     ComponentResult _rv;
9829     MediaHandler mh;
9830     long refConID;
9831     long refCon;
9832 #ifndef FlashMediaIDToRefCon
9833     PyMac_PRECHECK(FlashMediaIDToRefCon);
9834 #endif
9835     if (!PyArg_ParseTuple(_args, "O&l",
9836                           CmpInstObj_Convert, &mh,
9837                           &refConID))
9838         return NULL;
9839     _rv = FlashMediaIDToRefCon(mh,
9840                                refConID,
9841                                &refCon);
9842     _res = Py_BuildValue("ll",
9843                          _rv,
9844                          refCon);
9845     return _res;
9846 }
9847
9848 static PyObject *Qt_FlashMediaGetDisplayedFrameNumber(PyObject *_self, PyObject *_args)
9849 {
9850     PyObject *_res = NULL;
9851     ComponentResult _rv;
9852     MediaHandler mh;
9853     long flashFrameNumber;
9854 #ifndef FlashMediaGetDisplayedFrameNumber
9855     PyMac_PRECHECK(FlashMediaGetDisplayedFrameNumber);
9856 #endif
9857     if (!PyArg_ParseTuple(_args, "O&",
9858                           CmpInstObj_Convert, &mh))
9859         return NULL;
9860     _rv = FlashMediaGetDisplayedFrameNumber(mh,
9861                                             &flashFrameNumber);
9862     _res = Py_BuildValue("ll",
9863                          _rv,
9864                          flashFrameNumber);
9865     return _res;
9866 }
9867
9868 static PyObject *Qt_FlashMediaFrameNumberToMovieTime(PyObject *_self, PyObject *_args)
9869 {
9870     PyObject *_res = NULL;
9871     ComponentResult _rv;
9872     MediaHandler mh;
9873     long flashFrameNumber;
9874     TimeValue movieTime;
9875 #ifndef FlashMediaFrameNumberToMovieTime
9876     PyMac_PRECHECK(FlashMediaFrameNumberToMovieTime);
9877 #endif
9878     if (!PyArg_ParseTuple(_args, "O&l",
9879                           CmpInstObj_Convert, &mh,
9880                           &flashFrameNumber))
9881         return NULL;
9882     _rv = FlashMediaFrameNumberToMovieTime(mh,
9883                                            flashFrameNumber,
9884                                            &movieTime);
9885     _res = Py_BuildValue("ll",
9886                          _rv,
9887                          movieTime);
9888     return _res;
9889 }
9890
9891 static PyObject *Qt_FlashMediaFrameLabelToMovieTime(PyObject *_self, PyObject *_args)
9892 {
9893     PyObject *_res = NULL;
9894     ComponentResult _rv;
9895     MediaHandler mh;
9896     Ptr theLabel;
9897     TimeValue movieTime;
9898 #ifndef FlashMediaFrameLabelToMovieTime
9899     PyMac_PRECHECK(FlashMediaFrameLabelToMovieTime);
9900 #endif
9901     if (!PyArg_ParseTuple(_args, "O&s",
9902                           CmpInstObj_Convert, &mh,
9903                           &theLabel))
9904         return NULL;
9905     _rv = FlashMediaFrameLabelToMovieTime(mh,
9906                                           theLabel,
9907                                           &movieTime);
9908     _res = Py_BuildValue("ll",
9909                          _rv,
9910                          movieTime);
9911     return _res;
9912 }
9913
9914 static PyObject *Qt_FlashMediaGetFlashVariable(PyObject *_self, PyObject *_args)
9915 {
9916     PyObject *_res = NULL;
9917     ComponentResult _rv;
9918     MediaHandler mh;
9919     char path;
9920     char name;
9921     Handle theVariableCStringOut;
9922 #ifndef FlashMediaGetFlashVariable
9923     PyMac_PRECHECK(FlashMediaGetFlashVariable);
9924 #endif
9925     if (!PyArg_ParseTuple(_args, "O&",
9926                           CmpInstObj_Convert, &mh))
9927         return NULL;
9928     _rv = FlashMediaGetFlashVariable(mh,
9929                                      &path,
9930                                      &name,
9931                                      &theVariableCStringOut);
9932     _res = Py_BuildValue("lccO&",
9933                          _rv,
9934                          path,
9935                          name,
9936                          ResObj_New, theVariableCStringOut);
9937     return _res;
9938 }
9939
9940 static PyObject *Qt_FlashMediaSetFlashVariable(PyObject *_self, PyObject *_args)
9941 {
9942     PyObject *_res = NULL;
9943     ComponentResult _rv;
9944     MediaHandler mh;
9945     char path;
9946     char name;
9947     char value;
9948     Boolean updateFocus;
9949 #ifndef FlashMediaSetFlashVariable
9950     PyMac_PRECHECK(FlashMediaSetFlashVariable);
9951 #endif
9952     if (!PyArg_ParseTuple(_args, "O&b",
9953                           CmpInstObj_Convert, &mh,
9954                           &updateFocus))
9955         return NULL;
9956     _rv = FlashMediaSetFlashVariable(mh,
9957                                      &path,
9958                                      &name,
9959                                      &value,
9960                                      updateFocus);
9961     _res = Py_BuildValue("lccc",
9962                          _rv,
9963                          path,
9964                          name,
9965                          value);
9966     return _res;
9967 }
9968
9969 static PyObject *Qt_FlashMediaDoButtonActions(PyObject *_self, PyObject *_args)
9970 {
9971     PyObject *_res = NULL;
9972     ComponentResult _rv;
9973     MediaHandler mh;
9974     char path;
9975     long buttonID;
9976     long transition;
9977 #ifndef FlashMediaDoButtonActions
9978     PyMac_PRECHECK(FlashMediaDoButtonActions);
9979 #endif
9980     if (!PyArg_ParseTuple(_args, "O&ll",
9981                           CmpInstObj_Convert, &mh,
9982                           &buttonID,
9983                           &transition))
9984         return NULL;
9985     _rv = FlashMediaDoButtonActions(mh,
9986                                     &path,
9987                                     buttonID,
9988                                     transition);
9989     _res = Py_BuildValue("lc",
9990                          _rv,
9991                          path);
9992     return _res;
9993 }
9994
9995 static PyObject *Qt_FlashMediaGetSupportedSwfVersion(PyObject *_self, PyObject *_args)
9996 {
9997     PyObject *_res = NULL;
9998     ComponentResult _rv;
9999     MediaHandler mh;
10000     UInt8 swfVersion;
10001 #ifndef FlashMediaGetSupportedSwfVersion
10002     PyMac_PRECHECK(FlashMediaGetSupportedSwfVersion);
10003 #endif
10004     if (!PyArg_ParseTuple(_args, "O&",
10005                           CmpInstObj_Convert, &mh))
10006         return NULL;
10007     _rv = FlashMediaGetSupportedSwfVersion(mh,
10008                                            &swfVersion);
10009     _res = Py_BuildValue("lb",
10010                          _rv,
10011                          swfVersion);
10012     return _res;
10013 }
10014
10015 static PyObject *Qt_Media3DGetCurrentGroup(PyObject *_self, PyObject *_args)
10016 {
10017     PyObject *_res = NULL;
10018     ComponentResult _rv;
10019     MediaHandler mh;
10020     void * group;
10021 #ifndef Media3DGetCurrentGroup
10022     PyMac_PRECHECK(Media3DGetCurrentGroup);
10023 #endif
10024     if (!PyArg_ParseTuple(_args, "O&s",
10025                           CmpInstObj_Convert, &mh,
10026                           &group))
10027         return NULL;
10028     _rv = Media3DGetCurrentGroup(mh,
10029                                  group);
10030     _res = Py_BuildValue("l",
10031                          _rv);
10032     return _res;
10033 }
10034
10035 static PyObject *Qt_Media3DTranslateNamedObjectTo(PyObject *_self, PyObject *_args)
10036 {
10037     PyObject *_res = NULL;
10038     ComponentResult _rv;
10039     MediaHandler mh;
10040     char objectName;
10041     Fixed x;
10042     Fixed y;
10043     Fixed z;
10044 #ifndef Media3DTranslateNamedObjectTo
10045     PyMac_PRECHECK(Media3DTranslateNamedObjectTo);
10046 #endif
10047     if (!PyArg_ParseTuple(_args, "O&O&O&O&",
10048                           CmpInstObj_Convert, &mh,
10049                           PyMac_GetFixed, &x,
10050                           PyMac_GetFixed, &y,
10051                           PyMac_GetFixed, &z))
10052         return NULL;
10053     _rv = Media3DTranslateNamedObjectTo(mh,
10054                                         &objectName,
10055                                         x,
10056                                         y,
10057                                         z);
10058     _res = Py_BuildValue("lc",
10059                          _rv,
10060                          objectName);
10061     return _res;
10062 }
10063
10064 static PyObject *Qt_Media3DScaleNamedObjectTo(PyObject *_self, PyObject *_args)
10065 {
10066     PyObject *_res = NULL;
10067     ComponentResult _rv;
10068     MediaHandler mh;
10069     char objectName;
10070     Fixed xScale;
10071     Fixed yScale;
10072     Fixed zScale;
10073 #ifndef Media3DScaleNamedObjectTo
10074     PyMac_PRECHECK(Media3DScaleNamedObjectTo);
10075 #endif
10076     if (!PyArg_ParseTuple(_args, "O&O&O&O&",
10077                           CmpInstObj_Convert, &mh,
10078                           PyMac_GetFixed, &xScale,
10079                           PyMac_GetFixed, &yScale,
10080                           PyMac_GetFixed, &zScale))
10081         return NULL;
10082     _rv = Media3DScaleNamedObjectTo(mh,
10083                                     &objectName,
10084                                     xScale,
10085                                     yScale,
10086                                     zScale);
10087     _res = Py_BuildValue("lc",
10088                          _rv,
10089                          objectName);
10090     return _res;
10091 }
10092
10093 static PyObject *Qt_Media3DRotateNamedObjectTo(PyObject *_self, PyObject *_args)
10094 {
10095     PyObject *_res = NULL;
10096     ComponentResult _rv;
10097     MediaHandler mh;
10098     char objectName;
10099     Fixed xDegrees;
10100     Fixed yDegrees;
10101     Fixed zDegrees;
10102 #ifndef Media3DRotateNamedObjectTo
10103     PyMac_PRECHECK(Media3DRotateNamedObjectTo);
10104 #endif
10105     if (!PyArg_ParseTuple(_args, "O&O&O&O&",
10106                           CmpInstObj_Convert, &mh,
10107                           PyMac_GetFixed, &xDegrees,
10108                           PyMac_GetFixed, &yDegrees,
10109                           PyMac_GetFixed, &zDegrees))
10110         return NULL;
10111     _rv = Media3DRotateNamedObjectTo(mh,
10112                                      &objectName,
10113                                      xDegrees,
10114                                      yDegrees,
10115                                      zDegrees);
10116     _res = Py_BuildValue("lc",
10117                          _rv,
10118                          objectName);
10119     return _res;
10120 }
10121
10122 static PyObject *Qt_Media3DSetCameraData(PyObject *_self, PyObject *_args)
10123 {
10124     PyObject *_res = NULL;
10125     ComponentResult _rv;
10126     MediaHandler mh;
10127     void * cameraData;
10128 #ifndef Media3DSetCameraData
10129     PyMac_PRECHECK(Media3DSetCameraData);
10130 #endif
10131     if (!PyArg_ParseTuple(_args, "O&s",
10132                           CmpInstObj_Convert, &mh,
10133                           &cameraData))
10134         return NULL;
10135     _rv = Media3DSetCameraData(mh,
10136                                cameraData);
10137     _res = Py_BuildValue("l",
10138                          _rv);
10139     return _res;
10140 }
10141
10142 static PyObject *Qt_Media3DGetCameraData(PyObject *_self, PyObject *_args)
10143 {
10144     PyObject *_res = NULL;
10145     ComponentResult _rv;
10146     MediaHandler mh;
10147     void * cameraData;
10148 #ifndef Media3DGetCameraData
10149     PyMac_PRECHECK(Media3DGetCameraData);
10150 #endif
10151     if (!PyArg_ParseTuple(_args, "O&s",
10152                           CmpInstObj_Convert, &mh,
10153                           &cameraData))
10154         return NULL;
10155     _rv = Media3DGetCameraData(mh,
10156                                cameraData);
10157     _res = Py_BuildValue("l",
10158                          _rv);
10159     return _res;
10160 }
10161
10162 static PyObject *Qt_Media3DSetCameraAngleAspect(PyObject *_self, PyObject *_args)
10163 {
10164     PyObject *_res = NULL;
10165     ComponentResult _rv;
10166     MediaHandler mh;
10167     QTFloatSingle fov;
10168     QTFloatSingle aspectRatioXToY;
10169 #ifndef Media3DSetCameraAngleAspect
10170     PyMac_PRECHECK(Media3DSetCameraAngleAspect);
10171 #endif
10172     if (!PyArg_ParseTuple(_args, "O&ff",
10173                           CmpInstObj_Convert, &mh,
10174                           &fov,
10175                           &aspectRatioXToY))
10176         return NULL;
10177     _rv = Media3DSetCameraAngleAspect(mh,
10178                                       fov,
10179                                       aspectRatioXToY);
10180     _res = Py_BuildValue("l",
10181                          _rv);
10182     return _res;
10183 }
10184
10185 static PyObject *Qt_Media3DGetCameraAngleAspect(PyObject *_self, PyObject *_args)
10186 {
10187     PyObject *_res = NULL;
10188     ComponentResult _rv;
10189     MediaHandler mh;
10190     QTFloatSingle fov;
10191     QTFloatSingle aspectRatioXToY;
10192 #ifndef Media3DGetCameraAngleAspect
10193     PyMac_PRECHECK(Media3DGetCameraAngleAspect);
10194 #endif
10195     if (!PyArg_ParseTuple(_args, "O&",
10196                           CmpInstObj_Convert, &mh))
10197         return NULL;
10198     _rv = Media3DGetCameraAngleAspect(mh,
10199                                       &fov,
10200                                       &aspectRatioXToY);
10201     _res = Py_BuildValue("lff",
10202                          _rv,
10203                          fov,
10204                          aspectRatioXToY);
10205     return _res;
10206 }
10207
10208 static PyObject *Qt_Media3DSetCameraRange(PyObject *_self, PyObject *_args)
10209 {
10210     PyObject *_res = NULL;
10211     ComponentResult _rv;
10212     MediaHandler mh;
10213     void * tQ3CameraRange;
10214 #ifndef Media3DSetCameraRange
10215     PyMac_PRECHECK(Media3DSetCameraRange);
10216 #endif
10217     if (!PyArg_ParseTuple(_args, "O&s",
10218                           CmpInstObj_Convert, &mh,
10219                           &tQ3CameraRange))
10220         return NULL;
10221     _rv = Media3DSetCameraRange(mh,
10222                                 tQ3CameraRange);
10223     _res = Py_BuildValue("l",
10224                          _rv);
10225     return _res;
10226 }
10227
10228 static PyObject *Qt_Media3DGetCameraRange(PyObject *_self, PyObject *_args)
10229 {
10230     PyObject *_res = NULL;
10231     ComponentResult _rv;
10232     MediaHandler mh;
10233     void * tQ3CameraRange;
10234 #ifndef Media3DGetCameraRange
10235     PyMac_PRECHECK(Media3DGetCameraRange);
10236 #endif
10237     if (!PyArg_ParseTuple(_args, "O&s",
10238                           CmpInstObj_Convert, &mh,
10239                           &tQ3CameraRange))
10240         return NULL;
10241     _rv = Media3DGetCameraRange(mh,
10242                                 tQ3CameraRange);
10243     _res = Py_BuildValue("l",
10244                          _rv);
10245     return _res;
10246 }
10247
10248 static PyObject *Qt_NewTimeBase(PyObject *_self, PyObject *_args)
10249 {
10250     PyObject *_res = NULL;
10251     TimeBase _rv;
10252 #ifndef NewTimeBase
10253     PyMac_PRECHECK(NewTimeBase);
10254 #endif
10255     if (!PyArg_ParseTuple(_args, ""))
10256         return NULL;
10257     _rv = NewTimeBase();
10258     _res = Py_BuildValue("O&",
10259                          TimeBaseObj_New, _rv);
10260     return _res;
10261 }
10262
10263 static PyObject *Qt_ConvertTime(PyObject *_self, PyObject *_args)
10264 {
10265     PyObject *_res = NULL;
10266     TimeRecord theTime;
10267     TimeBase newBase;
10268 #ifndef ConvertTime
10269     PyMac_PRECHECK(ConvertTime);
10270 #endif
10271     if (!PyArg_ParseTuple(_args, "O&O&",
10272                           QtTimeRecord_Convert, &theTime,
10273                           TimeBaseObj_Convert, &newBase))
10274         return NULL;
10275     ConvertTime(&theTime,
10276                 newBase);
10277     _res = Py_BuildValue("O&",
10278                          QtTimeRecord_New, &theTime);
10279     return _res;
10280 }
10281
10282 static PyObject *Qt_ConvertTimeScale(PyObject *_self, PyObject *_args)
10283 {
10284     PyObject *_res = NULL;
10285     TimeRecord theTime;
10286     TimeScale newScale;
10287 #ifndef ConvertTimeScale
10288     PyMac_PRECHECK(ConvertTimeScale);
10289 #endif
10290     if (!PyArg_ParseTuple(_args, "O&l",
10291                           QtTimeRecord_Convert, &theTime,
10292                           &newScale))
10293         return NULL;
10294     ConvertTimeScale(&theTime,
10295                      newScale);
10296     _res = Py_BuildValue("O&",
10297                          QtTimeRecord_New, &theTime);
10298     return _res;
10299 }
10300
10301 static PyObject *Qt_AddTime(PyObject *_self, PyObject *_args)
10302 {
10303     PyObject *_res = NULL;
10304     TimeRecord dst;
10305     TimeRecord src;
10306 #ifndef AddTime
10307     PyMac_PRECHECK(AddTime);
10308 #endif
10309     if (!PyArg_ParseTuple(_args, "O&O&",
10310                           QtTimeRecord_Convert, &dst,
10311                           QtTimeRecord_Convert, &src))
10312         return NULL;
10313     AddTime(&dst,
10314         &src);
10315     _res = Py_BuildValue("O&",
10316                          QtTimeRecord_New, &dst);
10317     return _res;
10318 }
10319
10320 static PyObject *Qt_SubtractTime(PyObject *_self, PyObject *_args)
10321 {
10322     PyObject *_res = NULL;
10323     TimeRecord dst;
10324     TimeRecord src;
10325 #ifndef SubtractTime
10326     PyMac_PRECHECK(SubtractTime);
10327 #endif
10328     if (!PyArg_ParseTuple(_args, "O&O&",
10329                           QtTimeRecord_Convert, &dst,
10330                           QtTimeRecord_Convert, &src))
10331         return NULL;
10332     SubtractTime(&dst,
10333                  &src);
10334     _res = Py_BuildValue("O&",
10335                          QtTimeRecord_New, &dst);
10336     return _res;
10337 }
10338
10339 static PyObject *Qt_MusicMediaGetIndexedTunePlayer(PyObject *_self, PyObject *_args)
10340 {
10341     PyObject *_res = NULL;
10342     ComponentResult _rv;
10343     ComponentInstance ti;
10344     long sampleDescIndex;
10345     ComponentInstance tp;
10346 #ifndef MusicMediaGetIndexedTunePlayer
10347     PyMac_PRECHECK(MusicMediaGetIndexedTunePlayer);
10348 #endif
10349     if (!PyArg_ParseTuple(_args, "O&l",
10350                           CmpInstObj_Convert, &ti,
10351                           &sampleDescIndex))
10352         return NULL;
10353     _rv = MusicMediaGetIndexedTunePlayer(ti,
10354                                          sampleDescIndex,
10355                                          &tp);
10356     _res = Py_BuildValue("lO&",
10357                          _rv,
10358                          CmpInstObj_New, tp);
10359     return _res;
10360 }
10361
10362 static PyObject *Qt_CodecManagerVersion(PyObject *_self, PyObject *_args)
10363 {
10364     PyObject *_res = NULL;
10365     OSErr _err;
10366     long version;
10367 #ifndef CodecManagerVersion
10368     PyMac_PRECHECK(CodecManagerVersion);
10369 #endif
10370     if (!PyArg_ParseTuple(_args, ""))
10371         return NULL;
10372     _err = CodecManagerVersion(&version);
10373     if (_err != noErr) return PyMac_Error(_err);
10374     _res = Py_BuildValue("l",
10375                          version);
10376     return _res;
10377 }
10378
10379 static PyObject *Qt_GetMaxCompressionSize(PyObject *_self, PyObject *_args)
10380 {
10381     PyObject *_res = NULL;
10382     OSErr _err;
10383     PixMapHandle src;
10384     Rect srcRect;
10385     short colorDepth;
10386     CodecQ quality;
10387     CodecType cType;
10388     CompressorComponent codec;
10389     long size;
10390 #ifndef GetMaxCompressionSize
10391     PyMac_PRECHECK(GetMaxCompressionSize);
10392 #endif
10393     if (!PyArg_ParseTuple(_args, "O&O&hlO&O&",
10394                           ResObj_Convert, &src,
10395                           PyMac_GetRect, &srcRect,
10396                           &colorDepth,
10397                           &quality,
10398                           PyMac_GetOSType, &cType,
10399                           CmpObj_Convert, &codec))
10400         return NULL;
10401     _err = GetMaxCompressionSize(src,
10402                                  &srcRect,
10403                                  colorDepth,
10404                                  quality,
10405                                  cType,
10406                                  codec,
10407                                  &size);
10408     if (_err != noErr) return PyMac_Error(_err);
10409     _res = Py_BuildValue("l",
10410                          size);
10411     return _res;
10412 }
10413
10414 static PyObject *Qt_GetCompressionTime(PyObject *_self, PyObject *_args)
10415 {
10416     PyObject *_res = NULL;
10417     OSErr _err;
10418     PixMapHandle src;
10419     Rect srcRect;
10420     short colorDepth;
10421     CodecType cType;
10422     CompressorComponent codec;
10423     CodecQ spatialQuality;
10424     CodecQ temporalQuality;
10425     unsigned long compressTime;
10426 #ifndef GetCompressionTime
10427     PyMac_PRECHECK(GetCompressionTime);
10428 #endif
10429     if (!PyArg_ParseTuple(_args, "O&O&hO&O&",
10430                           ResObj_Convert, &src,
10431                           PyMac_GetRect, &srcRect,
10432                           &colorDepth,
10433                           PyMac_GetOSType, &cType,
10434                           CmpObj_Convert, &codec))
10435         return NULL;
10436     _err = GetCompressionTime(src,
10437                               &srcRect,
10438                               colorDepth,
10439                               cType,
10440                               codec,
10441                               &spatialQuality,
10442                               &temporalQuality,
10443                               &compressTime);
10444     if (_err != noErr) return PyMac_Error(_err);
10445     _res = Py_BuildValue("lll",
10446                          spatialQuality,
10447                          temporalQuality,
10448                          compressTime);
10449     return _res;
10450 }
10451
10452 static PyObject *Qt_CompressImage(PyObject *_self, PyObject *_args)
10453 {
10454     PyObject *_res = NULL;
10455     OSErr _err;
10456     PixMapHandle src;
10457     Rect srcRect;
10458     CodecQ quality;
10459     CodecType cType;
10460     ImageDescriptionHandle desc;
10461     Ptr data;
10462 #ifndef CompressImage
10463     PyMac_PRECHECK(CompressImage);
10464 #endif
10465     if (!PyArg_ParseTuple(_args, "O&O&lO&O&s",
10466                           ResObj_Convert, &src,
10467                           PyMac_GetRect, &srcRect,
10468                           &quality,
10469                           PyMac_GetOSType, &cType,
10470                           ResObj_Convert, &desc,
10471                           &data))
10472         return NULL;
10473     _err = CompressImage(src,
10474                          &srcRect,
10475                          quality,
10476                          cType,
10477                          desc,
10478                          data);
10479     if (_err != noErr) return PyMac_Error(_err);
10480     Py_INCREF(Py_None);
10481     _res = Py_None;
10482     return _res;
10483 }
10484
10485 static PyObject *Qt_DecompressImage(PyObject *_self, PyObject *_args)
10486 {
10487     PyObject *_res = NULL;
10488     OSErr _err;
10489     Ptr data;
10490     ImageDescriptionHandle desc;
10491     PixMapHandle dst;
10492     Rect srcRect;
10493     Rect dstRect;
10494     short mode;
10495     RgnHandle mask;
10496 #ifndef DecompressImage
10497     PyMac_PRECHECK(DecompressImage);
10498 #endif
10499     if (!PyArg_ParseTuple(_args, "sO&O&O&O&hO&",
10500                           &data,
10501                           ResObj_Convert, &desc,
10502                           ResObj_Convert, &dst,
10503                           PyMac_GetRect, &srcRect,
10504                           PyMac_GetRect, &dstRect,
10505                           &mode,
10506                           ResObj_Convert, &mask))
10507         return NULL;
10508     _err = DecompressImage(data,
10509                            desc,
10510                            dst,
10511                            &srcRect,
10512                            &dstRect,
10513                            mode,
10514                            mask);
10515     if (_err != noErr) return PyMac_Error(_err);
10516     Py_INCREF(Py_None);
10517     _res = Py_None;
10518     return _res;
10519 }
10520
10521 static PyObject *Qt_GetSimilarity(PyObject *_self, PyObject *_args)
10522 {
10523     PyObject *_res = NULL;
10524     OSErr _err;
10525     PixMapHandle src;
10526     Rect srcRect;
10527     ImageDescriptionHandle desc;
10528     Ptr data;
10529     Fixed similarity;
10530 #ifndef GetSimilarity
10531     PyMac_PRECHECK(GetSimilarity);
10532 #endif
10533     if (!PyArg_ParseTuple(_args, "O&O&O&s",
10534                           ResObj_Convert, &src,
10535                           PyMac_GetRect, &srcRect,
10536                           ResObj_Convert, &desc,
10537                           &data))
10538         return NULL;
10539     _err = GetSimilarity(src,
10540                          &srcRect,
10541                          desc,
10542                          data,
10543                          &similarity);
10544     if (_err != noErr) return PyMac_Error(_err);
10545     _res = Py_BuildValue("O&",
10546                          PyMac_BuildFixed, similarity);
10547     return _res;
10548 }
10549
10550 static PyObject *Qt_GetImageDescriptionCTable(PyObject *_self, PyObject *_args)
10551 {
10552     PyObject *_res = NULL;
10553     OSErr _err;
10554     ImageDescriptionHandle desc;
10555     CTabHandle ctable;
10556 #ifndef GetImageDescriptionCTable
10557     PyMac_PRECHECK(GetImageDescriptionCTable);
10558 #endif
10559     if (!PyArg_ParseTuple(_args, "O&",
10560                           ResObj_Convert, &desc))
10561         return NULL;
10562     _err = GetImageDescriptionCTable(desc,
10563                                      &ctable);
10564     if (_err != noErr) return PyMac_Error(_err);
10565     _res = Py_BuildValue("O&",
10566                          ResObj_New, ctable);
10567     return _res;
10568 }
10569
10570 static PyObject *Qt_SetImageDescriptionCTable(PyObject *_self, PyObject *_args)
10571 {
10572     PyObject *_res = NULL;
10573     OSErr _err;
10574     ImageDescriptionHandle desc;
10575     CTabHandle ctable;
10576 #ifndef SetImageDescriptionCTable
10577     PyMac_PRECHECK(SetImageDescriptionCTable);
10578 #endif
10579     if (!PyArg_ParseTuple(_args, "O&O&",
10580                           ResObj_Convert, &desc,
10581                           ResObj_Convert, &ctable))
10582         return NULL;
10583     _err = SetImageDescriptionCTable(desc,
10584                                      ctable);
10585     if (_err != noErr) return PyMac_Error(_err);
10586     Py_INCREF(Py_None);
10587     _res = Py_None;
10588     return _res;
10589 }
10590
10591 static PyObject *Qt_GetImageDescriptionExtension(PyObject *_self, PyObject *_args)
10592 {
10593     PyObject *_res = NULL;
10594     OSErr _err;
10595     ImageDescriptionHandle desc;
10596     Handle extension;
10597     long idType;
10598     long index;
10599 #ifndef GetImageDescriptionExtension
10600     PyMac_PRECHECK(GetImageDescriptionExtension);
10601 #endif
10602     if (!PyArg_ParseTuple(_args, "O&ll",
10603                           ResObj_Convert, &desc,
10604                           &idType,
10605                           &index))
10606         return NULL;
10607     _err = GetImageDescriptionExtension(desc,
10608                                         &extension,
10609                                         idType,
10610                                         index);
10611     if (_err != noErr) return PyMac_Error(_err);
10612     _res = Py_BuildValue("O&",
10613                          ResObj_New, extension);
10614     return _res;
10615 }
10616
10617 static PyObject *Qt_AddImageDescriptionExtension(PyObject *_self, PyObject *_args)
10618 {
10619     PyObject *_res = NULL;
10620     OSErr _err;
10621     ImageDescriptionHandle desc;
10622     Handle extension;
10623     long idType;
10624 #ifndef AddImageDescriptionExtension
10625     PyMac_PRECHECK(AddImageDescriptionExtension);
10626 #endif
10627     if (!PyArg_ParseTuple(_args, "O&O&l",
10628                           ResObj_Convert, &desc,
10629                           ResObj_Convert, &extension,
10630                           &idType))
10631         return NULL;
10632     _err = AddImageDescriptionExtension(desc,
10633                                         extension,
10634                                         idType);
10635     if (_err != noErr) return PyMac_Error(_err);
10636     Py_INCREF(Py_None);
10637     _res = Py_None;
10638     return _res;
10639 }
10640
10641 static PyObject *Qt_RemoveImageDescriptionExtension(PyObject *_self, PyObject *_args)
10642 {
10643     PyObject *_res = NULL;
10644     OSErr _err;
10645     ImageDescriptionHandle desc;
10646     long idType;
10647     long index;
10648 #ifndef RemoveImageDescriptionExtension
10649     PyMac_PRECHECK(RemoveImageDescriptionExtension);
10650 #endif
10651     if (!PyArg_ParseTuple(_args, "O&ll",
10652                           ResObj_Convert, &desc,
10653                           &idType,
10654                           &index))
10655         return NULL;
10656     _err = RemoveImageDescriptionExtension(desc,
10657                                            idType,
10658                                            index);
10659     if (_err != noErr) return PyMac_Error(_err);
10660     Py_INCREF(Py_None);
10661     _res = Py_None;
10662     return _res;
10663 }
10664
10665 static PyObject *Qt_CountImageDescriptionExtensionType(PyObject *_self, PyObject *_args)
10666 {
10667     PyObject *_res = NULL;
10668     OSErr _err;
10669     ImageDescriptionHandle desc;
10670     long idType;
10671     long count;
10672 #ifndef CountImageDescriptionExtensionType
10673     PyMac_PRECHECK(CountImageDescriptionExtensionType);
10674 #endif
10675     if (!PyArg_ParseTuple(_args, "O&l",
10676                           ResObj_Convert, &desc,
10677                           &idType))
10678         return NULL;
10679     _err = CountImageDescriptionExtensionType(desc,
10680                                               idType,
10681                                               &count);
10682     if (_err != noErr) return PyMac_Error(_err);
10683     _res = Py_BuildValue("l",
10684                          count);
10685     return _res;
10686 }
10687
10688 static PyObject *Qt_GetNextImageDescriptionExtensionType(PyObject *_self, PyObject *_args)
10689 {
10690     PyObject *_res = NULL;
10691     OSErr _err;
10692     ImageDescriptionHandle desc;
10693     long idType;
10694 #ifndef GetNextImageDescriptionExtensionType
10695     PyMac_PRECHECK(GetNextImageDescriptionExtensionType);
10696 #endif
10697     if (!PyArg_ParseTuple(_args, "O&",
10698                           ResObj_Convert, &desc))
10699         return NULL;
10700     _err = GetNextImageDescriptionExtensionType(desc,
10701                                                 &idType);
10702     if (_err != noErr) return PyMac_Error(_err);
10703     _res = Py_BuildValue("l",
10704                          idType);
10705     return _res;
10706 }
10707
10708 static PyObject *Qt_FindCodec(PyObject *_self, PyObject *_args)
10709 {
10710     PyObject *_res = NULL;
10711     OSErr _err;
10712     CodecType cType;
10713     CodecComponent specCodec;
10714     CompressorComponent compressor;
10715     DecompressorComponent decompressor;
10716 #ifndef FindCodec
10717     PyMac_PRECHECK(FindCodec);
10718 #endif
10719     if (!PyArg_ParseTuple(_args, "O&O&",
10720                           PyMac_GetOSType, &cType,
10721                           CmpObj_Convert, &specCodec))
10722         return NULL;
10723     _err = FindCodec(cType,
10724                      specCodec,
10725                      &compressor,
10726                      &decompressor);
10727     if (_err != noErr) return PyMac_Error(_err);
10728     _res = Py_BuildValue("O&O&",
10729                          CmpObj_New, compressor,
10730                          CmpObj_New, decompressor);
10731     return _res;
10732 }
10733
10734 static PyObject *Qt_CompressPicture(PyObject *_self, PyObject *_args)
10735 {
10736     PyObject *_res = NULL;
10737     OSErr _err;
10738     PicHandle srcPicture;
10739     PicHandle dstPicture;
10740     CodecQ quality;
10741     CodecType cType;
10742 #ifndef CompressPicture
10743     PyMac_PRECHECK(CompressPicture);
10744 #endif
10745     if (!PyArg_ParseTuple(_args, "O&O&lO&",
10746                           ResObj_Convert, &srcPicture,
10747                           ResObj_Convert, &dstPicture,
10748                           &quality,
10749                           PyMac_GetOSType, &cType))
10750         return NULL;
10751     _err = CompressPicture(srcPicture,
10752                            dstPicture,
10753                            quality,
10754                            cType);
10755     if (_err != noErr) return PyMac_Error(_err);
10756     Py_INCREF(Py_None);
10757     _res = Py_None;
10758     return _res;
10759 }
10760
10761 static PyObject *Qt_CompressPictureFile(PyObject *_self, PyObject *_args)
10762 {
10763     PyObject *_res = NULL;
10764     OSErr _err;
10765     short srcRefNum;
10766     short dstRefNum;
10767     CodecQ quality;
10768     CodecType cType;
10769 #ifndef CompressPictureFile
10770     PyMac_PRECHECK(CompressPictureFile);
10771 #endif
10772     if (!PyArg_ParseTuple(_args, "hhlO&",
10773                           &srcRefNum,
10774                           &dstRefNum,
10775                           &quality,
10776                           PyMac_GetOSType, &cType))
10777         return NULL;
10778     _err = CompressPictureFile(srcRefNum,
10779                                dstRefNum,
10780                                quality,
10781                                cType);
10782     if (_err != noErr) return PyMac_Error(_err);
10783     Py_INCREF(Py_None);
10784     _res = Py_None;
10785     return _res;
10786 }
10787
10788 static PyObject *Qt_ConvertImage(PyObject *_self, PyObject *_args)
10789 {
10790     PyObject *_res = NULL;
10791     OSErr _err;
10792     ImageDescriptionHandle srcDD;
10793     Ptr srcData;
10794     short colorDepth;
10795     CTabHandle ctable;
10796     CodecQ accuracy;
10797     CodecQ quality;
10798     CodecType cType;
10799     CodecComponent codec;
10800     ImageDescriptionHandle dstDD;
10801     Ptr dstData;
10802 #ifndef ConvertImage
10803     PyMac_PRECHECK(ConvertImage);
10804 #endif
10805     if (!PyArg_ParseTuple(_args, "O&shO&llO&O&O&s",
10806                           ResObj_Convert, &srcDD,
10807                           &srcData,
10808                           &colorDepth,
10809                           ResObj_Convert, &ctable,
10810                           &accuracy,
10811                           &quality,
10812                           PyMac_GetOSType, &cType,
10813                           CmpObj_Convert, &codec,
10814                           ResObj_Convert, &dstDD,
10815                           &dstData))
10816         return NULL;
10817     _err = ConvertImage(srcDD,
10818                         srcData,
10819                         colorDepth,
10820                         ctable,
10821                         accuracy,
10822                         quality,
10823                         cType,
10824                         codec,
10825                         dstDD,
10826                         dstData);
10827     if (_err != noErr) return PyMac_Error(_err);
10828     Py_INCREF(Py_None);
10829     _res = Py_None;
10830     return _res;
10831 }
10832
10833 static PyObject *Qt_AddFilePreview(PyObject *_self, PyObject *_args)
10834 {
10835     PyObject *_res = NULL;
10836     OSErr _err;
10837     short resRefNum;
10838     OSType previewType;
10839     Handle previewData;
10840 #ifndef AddFilePreview
10841     PyMac_PRECHECK(AddFilePreview);
10842 #endif
10843     if (!PyArg_ParseTuple(_args, "hO&O&",
10844                           &resRefNum,
10845                           PyMac_GetOSType, &previewType,
10846                           ResObj_Convert, &previewData))
10847         return NULL;
10848     _err = AddFilePreview(resRefNum,
10849                           previewType,
10850                           previewData);
10851     if (_err != noErr) return PyMac_Error(_err);
10852     Py_INCREF(Py_None);
10853     _res = Py_None;
10854     return _res;
10855 }
10856
10857 static PyObject *Qt_GetBestDeviceRect(PyObject *_self, PyObject *_args)
10858 {
10859     PyObject *_res = NULL;
10860     OSErr _err;
10861     GDHandle gdh;
10862     Rect rp;
10863 #ifndef GetBestDeviceRect
10864     PyMac_PRECHECK(GetBestDeviceRect);
10865 #endif
10866     if (!PyArg_ParseTuple(_args, ""))
10867         return NULL;
10868     _err = GetBestDeviceRect(&gdh,
10869                              &rp);
10870     if (_err != noErr) return PyMac_Error(_err);
10871     _res = Py_BuildValue("O&O&",
10872                          OptResObj_New, gdh,
10873                          PyMac_BuildRect, &rp);
10874     return _res;
10875 }
10876
10877 static PyObject *Qt_GDHasScale(PyObject *_self, PyObject *_args)
10878 {
10879     PyObject *_res = NULL;
10880     OSErr _err;
10881     GDHandle gdh;
10882     short depth;
10883     Fixed scale;
10884 #ifndef GDHasScale
10885     PyMac_PRECHECK(GDHasScale);
10886 #endif
10887     if (!PyArg_ParseTuple(_args, "O&h",
10888                           OptResObj_Convert, &gdh,
10889                           &depth))
10890         return NULL;
10891     _err = GDHasScale(gdh,
10892                       depth,
10893                       &scale);
10894     if (_err != noErr) return PyMac_Error(_err);
10895     _res = Py_BuildValue("O&",
10896                          PyMac_BuildFixed, scale);
10897     return _res;
10898 }
10899
10900 static PyObject *Qt_GDGetScale(PyObject *_self, PyObject *_args)
10901 {
10902     PyObject *_res = NULL;
10903     OSErr _err;
10904     GDHandle gdh;
10905     Fixed scale;
10906     short flags;
10907 #ifndef GDGetScale
10908     PyMac_PRECHECK(GDGetScale);
10909 #endif
10910     if (!PyArg_ParseTuple(_args, "O&",
10911                           OptResObj_Convert, &gdh))
10912         return NULL;
10913     _err = GDGetScale(gdh,
10914                       &scale,
10915                       &flags);
10916     if (_err != noErr) return PyMac_Error(_err);
10917     _res = Py_BuildValue("O&h",
10918                          PyMac_BuildFixed, scale,
10919                          flags);
10920     return _res;
10921 }
10922
10923 static PyObject *Qt_GDSetScale(PyObject *_self, PyObject *_args)
10924 {
10925     PyObject *_res = NULL;
10926     OSErr _err;
10927     GDHandle gdh;
10928     Fixed scale;
10929     short flags;
10930 #ifndef GDSetScale
10931     PyMac_PRECHECK(GDSetScale);
10932 #endif
10933     if (!PyArg_ParseTuple(_args, "O&O&h",
10934                           OptResObj_Convert, &gdh,
10935                           PyMac_GetFixed, &scale,
10936                           &flags))
10937         return NULL;
10938     _err = GDSetScale(gdh,
10939                       scale,
10940                       flags);
10941     if (_err != noErr) return PyMac_Error(_err);
10942     Py_INCREF(Py_None);
10943     _res = Py_None;
10944     return _res;
10945 }
10946
10947 static PyObject *Qt_GetGraphicsImporterForFile(PyObject *_self, PyObject *_args)
10948 {
10949     PyObject *_res = NULL;
10950     OSErr _err;
10951     FSSpec theFile;
10952     ComponentInstance gi;
10953 #ifndef GetGraphicsImporterForFile
10954     PyMac_PRECHECK(GetGraphicsImporterForFile);
10955 #endif
10956     if (!PyArg_ParseTuple(_args, "O&",
10957                           PyMac_GetFSSpec, &theFile))
10958         return NULL;
10959     _err = GetGraphicsImporterForFile(&theFile,
10960                                       &gi);
10961     if (_err != noErr) return PyMac_Error(_err);
10962     _res = Py_BuildValue("O&",
10963                          CmpInstObj_New, gi);
10964     return _res;
10965 }
10966
10967 static PyObject *Qt_GetGraphicsImporterForDataRef(PyObject *_self, PyObject *_args)
10968 {
10969     PyObject *_res = NULL;
10970     OSErr _err;
10971     Handle dataRef;
10972     OSType dataRefType;
10973     ComponentInstance gi;
10974 #ifndef GetGraphicsImporterForDataRef
10975     PyMac_PRECHECK(GetGraphicsImporterForDataRef);
10976 #endif
10977     if (!PyArg_ParseTuple(_args, "O&O&",
10978                           ResObj_Convert, &dataRef,
10979                           PyMac_GetOSType, &dataRefType))
10980         return NULL;
10981     _err = GetGraphicsImporterForDataRef(dataRef,
10982                                          dataRefType,
10983                                          &gi);
10984     if (_err != noErr) return PyMac_Error(_err);
10985     _res = Py_BuildValue("O&",
10986                          CmpInstObj_New, gi);
10987     return _res;
10988 }
10989
10990 static PyObject *Qt_GetGraphicsImporterForFileWithFlags(PyObject *_self, PyObject *_args)
10991 {
10992     PyObject *_res = NULL;
10993     OSErr _err;
10994     FSSpec theFile;
10995     ComponentInstance gi;
10996     long flags;
10997 #ifndef GetGraphicsImporterForFileWithFlags
10998     PyMac_PRECHECK(GetGraphicsImporterForFileWithFlags);
10999 #endif
11000     if (!PyArg_ParseTuple(_args, "O&l",
11001                           PyMac_GetFSSpec, &theFile,
11002                           &flags))
11003         return NULL;
11004     _err = GetGraphicsImporterForFileWithFlags(&theFile,
11005                                                &gi,
11006                                                flags);
11007     if (_err != noErr) return PyMac_Error(_err);
11008     _res = Py_BuildValue("O&",
11009                          CmpInstObj_New, gi);
11010     return _res;
11011 }
11012
11013 static PyObject *Qt_GetGraphicsImporterForDataRefWithFlags(PyObject *_self, PyObject *_args)
11014 {
11015     PyObject *_res = NULL;
11016     OSErr _err;
11017     Handle dataRef;
11018     OSType dataRefType;
11019     ComponentInstance gi;
11020     long flags;
11021 #ifndef GetGraphicsImporterForDataRefWithFlags
11022     PyMac_PRECHECK(GetGraphicsImporterForDataRefWithFlags);
11023 #endif
11024     if (!PyArg_ParseTuple(_args, "O&O&l",
11025                           ResObj_Convert, &dataRef,
11026                           PyMac_GetOSType, &dataRefType,
11027                           &flags))
11028         return NULL;
11029     _err = GetGraphicsImporterForDataRefWithFlags(dataRef,
11030                                                   dataRefType,
11031                                                   &gi,
11032                                                   flags);
11033     if (_err != noErr) return PyMac_Error(_err);
11034     _res = Py_BuildValue("O&",
11035                          CmpInstObj_New, gi);
11036     return _res;
11037 }
11038
11039 static PyObject *Qt_MakeImageDescriptionForPixMap(PyObject *_self, PyObject *_args)
11040 {
11041     PyObject *_res = NULL;
11042     OSErr _err;
11043     PixMapHandle pixmap;
11044     ImageDescriptionHandle idh;
11045 #ifndef MakeImageDescriptionForPixMap
11046     PyMac_PRECHECK(MakeImageDescriptionForPixMap);
11047 #endif
11048     if (!PyArg_ParseTuple(_args, "O&",
11049                           ResObj_Convert, &pixmap))
11050         return NULL;
11051     _err = MakeImageDescriptionForPixMap(pixmap,
11052                                          &idh);
11053     if (_err != noErr) return PyMac_Error(_err);
11054     _res = Py_BuildValue("O&",
11055                          ResObj_New, idh);
11056     return _res;
11057 }
11058
11059 static PyObject *Qt_MakeImageDescriptionForEffect(PyObject *_self, PyObject *_args)
11060 {
11061     PyObject *_res = NULL;
11062     OSErr _err;
11063     OSType effectType;
11064     ImageDescriptionHandle idh;
11065 #ifndef MakeImageDescriptionForEffect
11066     PyMac_PRECHECK(MakeImageDescriptionForEffect);
11067 #endif
11068     if (!PyArg_ParseTuple(_args, "O&",
11069                           PyMac_GetOSType, &effectType))
11070         return NULL;
11071     _err = MakeImageDescriptionForEffect(effectType,
11072                                          &idh);
11073     if (_err != noErr) return PyMac_Error(_err);
11074     _res = Py_BuildValue("O&",
11075                          ResObj_New, idh);
11076     return _res;
11077 }
11078
11079 static PyObject *Qt_QTGetPixelSize(PyObject *_self, PyObject *_args)
11080 {
11081     PyObject *_res = NULL;
11082     short _rv;
11083     OSType PixelFormat;
11084 #ifndef QTGetPixelSize
11085     PyMac_PRECHECK(QTGetPixelSize);
11086 #endif
11087     if (!PyArg_ParseTuple(_args, "O&",
11088                           PyMac_GetOSType, &PixelFormat))
11089         return NULL;
11090     _rv = QTGetPixelSize(PixelFormat);
11091     _res = Py_BuildValue("h",
11092                          _rv);
11093     return _res;
11094 }
11095
11096 static PyObject *Qt_QTGetPixelFormatDepthForImageDescription(PyObject *_self, PyObject *_args)
11097 {
11098     PyObject *_res = NULL;
11099     short _rv;
11100     OSType PixelFormat;
11101 #ifndef QTGetPixelFormatDepthForImageDescription
11102     PyMac_PRECHECK(QTGetPixelFormatDepthForImageDescription);
11103 #endif
11104     if (!PyArg_ParseTuple(_args, "O&",
11105                           PyMac_GetOSType, &PixelFormat))
11106         return NULL;
11107     _rv = QTGetPixelFormatDepthForImageDescription(PixelFormat);
11108     _res = Py_BuildValue("h",
11109                          _rv);
11110     return _res;
11111 }
11112
11113 static PyObject *Qt_QTGetPixMapHandleRowBytes(PyObject *_self, PyObject *_args)
11114 {
11115     PyObject *_res = NULL;
11116     long _rv;
11117     PixMapHandle pm;
11118 #ifndef QTGetPixMapHandleRowBytes
11119     PyMac_PRECHECK(QTGetPixMapHandleRowBytes);
11120 #endif
11121     if (!PyArg_ParseTuple(_args, "O&",
11122                           ResObj_Convert, &pm))
11123         return NULL;
11124     _rv = QTGetPixMapHandleRowBytes(pm);
11125     _res = Py_BuildValue("l",
11126                          _rv);
11127     return _res;
11128 }
11129
11130 static PyObject *Qt_QTSetPixMapHandleRowBytes(PyObject *_self, PyObject *_args)
11131 {
11132     PyObject *_res = NULL;
11133     OSErr _err;
11134     PixMapHandle pm;
11135     long rowBytes;
11136 #ifndef QTSetPixMapHandleRowBytes
11137     PyMac_PRECHECK(QTSetPixMapHandleRowBytes);
11138 #endif
11139     if (!PyArg_ParseTuple(_args, "O&l",
11140                           ResObj_Convert, &pm,
11141                           &rowBytes))
11142         return NULL;
11143     _err = QTSetPixMapHandleRowBytes(pm,
11144                                      rowBytes);
11145     if (_err != noErr) return PyMac_Error(_err);
11146     Py_INCREF(Py_None);
11147     _res = Py_None;
11148     return _res;
11149 }
11150
11151 static PyObject *Qt_QTGetPixMapHandleGammaLevel(PyObject *_self, PyObject *_args)
11152 {
11153     PyObject *_res = NULL;
11154     Fixed _rv;
11155     PixMapHandle pm;
11156 #ifndef QTGetPixMapHandleGammaLevel
11157     PyMac_PRECHECK(QTGetPixMapHandleGammaLevel);
11158 #endif
11159     if (!PyArg_ParseTuple(_args, "O&",
11160                           ResObj_Convert, &pm))
11161         return NULL;
11162     _rv = QTGetPixMapHandleGammaLevel(pm);
11163     _res = Py_BuildValue("O&",
11164                          PyMac_BuildFixed, _rv);
11165     return _res;
11166 }
11167
11168 static PyObject *Qt_QTSetPixMapHandleGammaLevel(PyObject *_self, PyObject *_args)
11169 {
11170     PyObject *_res = NULL;
11171     OSErr _err;
11172     PixMapHandle pm;
11173     Fixed gammaLevel;
11174 #ifndef QTSetPixMapHandleGammaLevel
11175     PyMac_PRECHECK(QTSetPixMapHandleGammaLevel);
11176 #endif
11177     if (!PyArg_ParseTuple(_args, "O&O&",
11178                           ResObj_Convert, &pm,
11179                           PyMac_GetFixed, &gammaLevel))
11180         return NULL;
11181     _err = QTSetPixMapHandleGammaLevel(pm,
11182                                        gammaLevel);
11183     if (_err != noErr) return PyMac_Error(_err);
11184     Py_INCREF(Py_None);
11185     _res = Py_None;
11186     return _res;
11187 }
11188
11189 static PyObject *Qt_QTGetPixMapHandleRequestedGammaLevel(PyObject *_self, PyObject *_args)
11190 {
11191     PyObject *_res = NULL;
11192     Fixed _rv;
11193     PixMapHandle pm;
11194 #ifndef QTGetPixMapHandleRequestedGammaLevel
11195     PyMac_PRECHECK(QTGetPixMapHandleRequestedGammaLevel);
11196 #endif
11197     if (!PyArg_ParseTuple(_args, "O&",
11198                           ResObj_Convert, &pm))
11199         return NULL;
11200     _rv = QTGetPixMapHandleRequestedGammaLevel(pm);
11201     _res = Py_BuildValue("O&",
11202                          PyMac_BuildFixed, _rv);
11203     return _res;
11204 }
11205
11206 static PyObject *Qt_QTSetPixMapHandleRequestedGammaLevel(PyObject *_self, PyObject *_args)
11207 {
11208     PyObject *_res = NULL;
11209     OSErr _err;
11210     PixMapHandle pm;
11211     Fixed requestedGammaLevel;
11212 #ifndef QTSetPixMapHandleRequestedGammaLevel
11213     PyMac_PRECHECK(QTSetPixMapHandleRequestedGammaLevel);
11214 #endif
11215     if (!PyArg_ParseTuple(_args, "O&O&",
11216                           ResObj_Convert, &pm,
11217                           PyMac_GetFixed, &requestedGammaLevel))
11218         return NULL;
11219     _err = QTSetPixMapHandleRequestedGammaLevel(pm,
11220                                                 requestedGammaLevel);
11221     if (_err != noErr) return PyMac_Error(_err);
11222     Py_INCREF(Py_None);
11223     _res = Py_None;
11224     return _res;
11225 }
11226
11227 static PyObject *Qt_CompAdd(PyObject *_self, PyObject *_args)
11228 {
11229     PyObject *_res = NULL;
11230     wide src;
11231     wide dst;
11232 #ifndef CompAdd
11233     PyMac_PRECHECK(CompAdd);
11234 #endif
11235     if (!PyArg_ParseTuple(_args, ""))
11236         return NULL;
11237     CompAdd(&src,
11238         &dst);
11239     _res = Py_BuildValue("O&O&",
11240                          PyMac_Buildwide, src,
11241                          PyMac_Buildwide, dst);
11242     return _res;
11243 }
11244
11245 static PyObject *Qt_CompSub(PyObject *_self, PyObject *_args)
11246 {
11247     PyObject *_res = NULL;
11248     wide src;
11249     wide dst;
11250 #ifndef CompSub
11251     PyMac_PRECHECK(CompSub);
11252 #endif
11253     if (!PyArg_ParseTuple(_args, ""))
11254         return NULL;
11255     CompSub(&src,
11256         &dst);
11257     _res = Py_BuildValue("O&O&",
11258                          PyMac_Buildwide, src,
11259                          PyMac_Buildwide, dst);
11260     return _res;
11261 }
11262
11263 static PyObject *Qt_CompNeg(PyObject *_self, PyObject *_args)
11264 {
11265     PyObject *_res = NULL;
11266     wide dst;
11267 #ifndef CompNeg
11268     PyMac_PRECHECK(CompNeg);
11269 #endif
11270     if (!PyArg_ParseTuple(_args, ""))
11271         return NULL;
11272     CompNeg(&dst);
11273     _res = Py_BuildValue("O&",
11274                          PyMac_Buildwide, dst);
11275     return _res;
11276 }
11277
11278 static PyObject *Qt_CompShift(PyObject *_self, PyObject *_args)
11279 {
11280     PyObject *_res = NULL;
11281     wide src;
11282     short shift;
11283 #ifndef CompShift
11284     PyMac_PRECHECK(CompShift);
11285 #endif
11286     if (!PyArg_ParseTuple(_args, "h",
11287                           &shift))
11288         return NULL;
11289     CompShift(&src,
11290               shift);
11291     _res = Py_BuildValue("O&",
11292                          PyMac_Buildwide, src);
11293     return _res;
11294 }
11295
11296 static PyObject *Qt_CompMul(PyObject *_self, PyObject *_args)
11297 {
11298     PyObject *_res = NULL;
11299     long src1;
11300     long src2;
11301     wide dst;
11302 #ifndef CompMul
11303     PyMac_PRECHECK(CompMul);
11304 #endif
11305     if (!PyArg_ParseTuple(_args, "ll",
11306                           &src1,
11307                           &src2))
11308         return NULL;
11309     CompMul(src1,
11310         src2,
11311         &dst);
11312     _res = Py_BuildValue("O&",
11313                          PyMac_Buildwide, dst);
11314     return _res;
11315 }
11316
11317 static PyObject *Qt_CompDiv(PyObject *_self, PyObject *_args)
11318 {
11319     PyObject *_res = NULL;
11320     long _rv;
11321     wide numerator;
11322     long denominator;
11323     long remainder;
11324 #ifndef CompDiv
11325     PyMac_PRECHECK(CompDiv);
11326 #endif
11327     if (!PyArg_ParseTuple(_args, "l",
11328                           &denominator))
11329         return NULL;
11330     _rv = CompDiv(&numerator,
11331                   denominator,
11332                   &remainder);
11333     _res = Py_BuildValue("lO&l",
11334                          _rv,
11335                          PyMac_Buildwide, numerator,
11336                          remainder);
11337     return _res;
11338 }
11339
11340 static PyObject *Qt_CompFixMul(PyObject *_self, PyObject *_args)
11341 {
11342     PyObject *_res = NULL;
11343     wide compSrc;
11344     Fixed fixSrc;
11345     wide compDst;
11346 #ifndef CompFixMul
11347     PyMac_PRECHECK(CompFixMul);
11348 #endif
11349     if (!PyArg_ParseTuple(_args, "O&",
11350                           PyMac_GetFixed, &fixSrc))
11351         return NULL;
11352     CompFixMul(&compSrc,
11353                fixSrc,
11354                &compDst);
11355     _res = Py_BuildValue("O&O&",
11356                          PyMac_Buildwide, compSrc,
11357                          PyMac_Buildwide, compDst);
11358     return _res;
11359 }
11360
11361 static PyObject *Qt_CompMulDiv(PyObject *_self, PyObject *_args)
11362 {
11363     PyObject *_res = NULL;
11364     wide co;
11365     long mul;
11366     long divisor;
11367 #ifndef CompMulDiv
11368     PyMac_PRECHECK(CompMulDiv);
11369 #endif
11370     if (!PyArg_ParseTuple(_args, "ll",
11371                           &mul,
11372                           &divisor))
11373         return NULL;
11374     CompMulDiv(&co,
11375                mul,
11376                divisor);
11377     _res = Py_BuildValue("O&",
11378                          PyMac_Buildwide, co);
11379     return _res;
11380 }
11381
11382 static PyObject *Qt_CompMulDivTrunc(PyObject *_self, PyObject *_args)
11383 {
11384     PyObject *_res = NULL;
11385     wide co;
11386     long mul;
11387     long divisor;
11388     long remainder;
11389 #ifndef CompMulDivTrunc
11390     PyMac_PRECHECK(CompMulDivTrunc);
11391 #endif
11392     if (!PyArg_ParseTuple(_args, "ll",
11393                           &mul,
11394                           &divisor))
11395         return NULL;
11396     CompMulDivTrunc(&co,
11397                     mul,
11398                     divisor,
11399                     &remainder);
11400     _res = Py_BuildValue("O&l",
11401                          PyMac_Buildwide, co,
11402                          remainder);
11403     return _res;
11404 }
11405
11406 static PyObject *Qt_CompCompare(PyObject *_self, PyObject *_args)
11407 {
11408     PyObject *_res = NULL;
11409     long _rv;
11410     wide a;
11411     wide minusb;
11412 #ifndef CompCompare
11413     PyMac_PRECHECK(CompCompare);
11414 #endif
11415     if (!PyArg_ParseTuple(_args, "O&O&",
11416                           PyMac_Getwide, &a,
11417                           PyMac_Getwide, &minusb))
11418         return NULL;
11419     _rv = CompCompare(&a,
11420                       &minusb);
11421     _res = Py_BuildValue("l",
11422                          _rv);
11423     return _res;
11424 }
11425
11426 static PyObject *Qt_CompSquareRoot(PyObject *_self, PyObject *_args)
11427 {
11428     PyObject *_res = NULL;
11429     unsigned long _rv;
11430     wide src;
11431 #ifndef CompSquareRoot
11432     PyMac_PRECHECK(CompSquareRoot);
11433 #endif
11434     if (!PyArg_ParseTuple(_args, "O&",
11435                           PyMac_Getwide, &src))
11436         return NULL;
11437     _rv = CompSquareRoot(&src);
11438     _res = Py_BuildValue("l",
11439                          _rv);
11440     return _res;
11441 }
11442
11443 static PyObject *Qt_FixMulDiv(PyObject *_self, PyObject *_args)
11444 {
11445     PyObject *_res = NULL;
11446     Fixed _rv;
11447     Fixed src;
11448     Fixed mul;
11449     Fixed divisor;
11450 #ifndef FixMulDiv
11451     PyMac_PRECHECK(FixMulDiv);
11452 #endif
11453     if (!PyArg_ParseTuple(_args, "O&O&O&",
11454                           PyMac_GetFixed, &src,
11455                           PyMac_GetFixed, &mul,
11456                           PyMac_GetFixed, &divisor))
11457         return NULL;
11458     _rv = FixMulDiv(src,
11459                     mul,
11460                     divisor);
11461     _res = Py_BuildValue("O&",
11462                          PyMac_BuildFixed, _rv);
11463     return _res;
11464 }
11465
11466 static PyObject *Qt_UnsignedFixMulDiv(PyObject *_self, PyObject *_args)
11467 {
11468     PyObject *_res = NULL;
11469     Fixed _rv;
11470     Fixed src;
11471     Fixed mul;
11472     Fixed divisor;
11473 #ifndef UnsignedFixMulDiv
11474     PyMac_PRECHECK(UnsignedFixMulDiv);
11475 #endif
11476     if (!PyArg_ParseTuple(_args, "O&O&O&",
11477                           PyMac_GetFixed, &src,
11478                           PyMac_GetFixed, &mul,
11479                           PyMac_GetFixed, &divisor))
11480         return NULL;
11481     _rv = UnsignedFixMulDiv(src,
11482                             mul,
11483                             divisor);
11484     _res = Py_BuildValue("O&",
11485                          PyMac_BuildFixed, _rv);
11486     return _res;
11487 }
11488
11489 static PyObject *Qt_FixExp2(PyObject *_self, PyObject *_args)
11490 {
11491     PyObject *_res = NULL;
11492     Fixed _rv;
11493     Fixed src;
11494 #ifndef FixExp2
11495     PyMac_PRECHECK(FixExp2);
11496 #endif
11497     if (!PyArg_ParseTuple(_args, "O&",
11498                           PyMac_GetFixed, &src))
11499         return NULL;
11500     _rv = FixExp2(src);
11501     _res = Py_BuildValue("O&",
11502                          PyMac_BuildFixed, _rv);
11503     return _res;
11504 }
11505
11506 static PyObject *Qt_FixLog2(PyObject *_self, PyObject *_args)
11507 {
11508     PyObject *_res = NULL;
11509     Fixed _rv;
11510     Fixed src;
11511 #ifndef FixLog2
11512     PyMac_PRECHECK(FixLog2);
11513 #endif
11514     if (!PyArg_ParseTuple(_args, "O&",
11515                           PyMac_GetFixed, &src))
11516         return NULL;
11517     _rv = FixLog2(src);
11518     _res = Py_BuildValue("O&",
11519                          PyMac_BuildFixed, _rv);
11520     return _res;
11521 }
11522
11523 static PyObject *Qt_FixPow(PyObject *_self, PyObject *_args)
11524 {
11525     PyObject *_res = NULL;
11526     Fixed _rv;
11527     Fixed base;
11528     Fixed exp;
11529 #ifndef FixPow
11530     PyMac_PRECHECK(FixPow);
11531 #endif
11532     if (!PyArg_ParseTuple(_args, "O&O&",
11533                           PyMac_GetFixed, &base,
11534                           PyMac_GetFixed, &exp))
11535         return NULL;
11536     _rv = FixPow(base,
11537                  exp);
11538     _res = Py_BuildValue("O&",
11539                          PyMac_BuildFixed, _rv);
11540     return _res;
11541 }
11542
11543 static PyObject *Qt_GraphicsImportSetDataReference(PyObject *_self, PyObject *_args)
11544 {
11545     PyObject *_res = NULL;
11546     ComponentResult _rv;
11547     GraphicsImportComponent ci;
11548     Handle dataRef;
11549     OSType dataReType;
11550 #ifndef GraphicsImportSetDataReference
11551     PyMac_PRECHECK(GraphicsImportSetDataReference);
11552 #endif
11553     if (!PyArg_ParseTuple(_args, "O&O&O&",
11554                           CmpInstObj_Convert, &ci,
11555                           ResObj_Convert, &dataRef,
11556                           PyMac_GetOSType, &dataReType))
11557         return NULL;
11558     _rv = GraphicsImportSetDataReference(ci,
11559                                          dataRef,
11560                                          dataReType);
11561     _res = Py_BuildValue("l",
11562                          _rv);
11563     return _res;
11564 }
11565
11566 static PyObject *Qt_GraphicsImportGetDataReference(PyObject *_self, PyObject *_args)
11567 {
11568     PyObject *_res = NULL;
11569     ComponentResult _rv;
11570     GraphicsImportComponent ci;
11571     Handle dataRef;
11572     OSType dataReType;
11573 #ifndef GraphicsImportGetDataReference
11574     PyMac_PRECHECK(GraphicsImportGetDataReference);
11575 #endif
11576     if (!PyArg_ParseTuple(_args, "O&",
11577                           CmpInstObj_Convert, &ci))
11578         return NULL;
11579     _rv = GraphicsImportGetDataReference(ci,
11580                                          &dataRef,
11581                                          &dataReType);
11582     _res = Py_BuildValue("lO&O&",
11583                          _rv,
11584                          ResObj_New, dataRef,
11585                          PyMac_BuildOSType, dataReType);
11586     return _res;
11587 }
11588
11589 static PyObject *Qt_GraphicsImportSetDataFile(PyObject *_self, PyObject *_args)
11590 {
11591     PyObject *_res = NULL;
11592     ComponentResult _rv;
11593     GraphicsImportComponent ci;
11594     FSSpec theFile;
11595 #ifndef GraphicsImportSetDataFile
11596     PyMac_PRECHECK(GraphicsImportSetDataFile);
11597 #endif
11598     if (!PyArg_ParseTuple(_args, "O&O&",
11599                           CmpInstObj_Convert, &ci,
11600                           PyMac_GetFSSpec, &theFile))
11601         return NULL;
11602     _rv = GraphicsImportSetDataFile(ci,
11603                                     &theFile);
11604     _res = Py_BuildValue("l",
11605                          _rv);
11606     return _res;
11607 }
11608
11609 static PyObject *Qt_GraphicsImportGetDataFile(PyObject *_self, PyObject *_args)
11610 {
11611     PyObject *_res = NULL;
11612     ComponentResult _rv;
11613     GraphicsImportComponent ci;
11614     FSSpec theFile;
11615 #ifndef GraphicsImportGetDataFile
11616     PyMac_PRECHECK(GraphicsImportGetDataFile);
11617 #endif
11618     if (!PyArg_ParseTuple(_args, "O&O&",
11619                           CmpInstObj_Convert, &ci,
11620                           PyMac_GetFSSpec, &theFile))
11621         return NULL;
11622     _rv = GraphicsImportGetDataFile(ci,
11623                                     &theFile);
11624     _res = Py_BuildValue("l",
11625                          _rv);
11626     return _res;
11627 }
11628
11629 static PyObject *Qt_GraphicsImportSetDataHandle(PyObject *_self, PyObject *_args)
11630 {
11631     PyObject *_res = NULL;
11632     ComponentResult _rv;
11633     GraphicsImportComponent ci;
11634     Handle h;
11635 #ifndef GraphicsImportSetDataHandle
11636     PyMac_PRECHECK(GraphicsImportSetDataHandle);
11637 #endif
11638     if (!PyArg_ParseTuple(_args, "O&O&",
11639                           CmpInstObj_Convert, &ci,
11640                           ResObj_Convert, &h))
11641         return NULL;
11642     _rv = GraphicsImportSetDataHandle(ci,
11643                                       h);
11644     _res = Py_BuildValue("l",
11645                          _rv);
11646     return _res;
11647 }
11648
11649 static PyObject *Qt_GraphicsImportGetDataHandle(PyObject *_self, PyObject *_args)
11650 {
11651     PyObject *_res = NULL;
11652     ComponentResult _rv;
11653     GraphicsImportComponent ci;
11654     Handle h;
11655 #ifndef GraphicsImportGetDataHandle
11656     PyMac_PRECHECK(GraphicsImportGetDataHandle);
11657 #endif
11658     if (!PyArg_ParseTuple(_args, "O&",
11659                           CmpInstObj_Convert, &ci))
11660         return NULL;
11661     _rv = GraphicsImportGetDataHandle(ci,
11662                                       &h);
11663     _res = Py_BuildValue("lO&",
11664                          _rv,
11665                          ResObj_New, h);
11666     return _res;
11667 }
11668
11669 static PyObject *Qt_GraphicsImportGetImageDescription(PyObject *_self, PyObject *_args)
11670 {
11671     PyObject *_res = NULL;
11672     ComponentResult _rv;
11673     GraphicsImportComponent ci;
11674     ImageDescriptionHandle desc;
11675 #ifndef GraphicsImportGetImageDescription
11676     PyMac_PRECHECK(GraphicsImportGetImageDescription);
11677 #endif
11678     if (!PyArg_ParseTuple(_args, "O&",
11679                           CmpInstObj_Convert, &ci))
11680         return NULL;
11681     _rv = GraphicsImportGetImageDescription(ci,
11682                                             &desc);
11683     _res = Py_BuildValue("lO&",
11684                          _rv,
11685                          ResObj_New, desc);
11686     return _res;
11687 }
11688
11689 static PyObject *Qt_GraphicsImportGetDataOffsetAndSize(PyObject *_self, PyObject *_args)
11690 {
11691     PyObject *_res = NULL;
11692     ComponentResult _rv;
11693     GraphicsImportComponent ci;
11694     unsigned long offset;
11695     unsigned long size;
11696 #ifndef GraphicsImportGetDataOffsetAndSize
11697     PyMac_PRECHECK(GraphicsImportGetDataOffsetAndSize);
11698 #endif
11699     if (!PyArg_ParseTuple(_args, "O&",
11700                           CmpInstObj_Convert, &ci))
11701         return NULL;
11702     _rv = GraphicsImportGetDataOffsetAndSize(ci,
11703                                              &offset,
11704                                              &size);
11705     _res = Py_BuildValue("lll",
11706                          _rv,
11707                          offset,
11708                          size);
11709     return _res;
11710 }
11711
11712 static PyObject *Qt_GraphicsImportReadData(PyObject *_self, PyObject *_args)
11713 {
11714     PyObject *_res = NULL;
11715     ComponentResult _rv;
11716     GraphicsImportComponent ci;
11717     void * dataPtr;
11718     unsigned long dataOffset;
11719     unsigned long dataSize;
11720 #ifndef GraphicsImportReadData
11721     PyMac_PRECHECK(GraphicsImportReadData);
11722 #endif
11723     if (!PyArg_ParseTuple(_args, "O&sll",
11724                           CmpInstObj_Convert, &ci,
11725                           &dataPtr,
11726                           &dataOffset,
11727                           &dataSize))
11728         return NULL;
11729     _rv = GraphicsImportReadData(ci,
11730                                  dataPtr,
11731                                  dataOffset,
11732                                  dataSize);
11733     _res = Py_BuildValue("l",
11734                          _rv);
11735     return _res;
11736 }
11737
11738 static PyObject *Qt_GraphicsImportSetClip(PyObject *_self, PyObject *_args)
11739 {
11740     PyObject *_res = NULL;
11741     ComponentResult _rv;
11742     GraphicsImportComponent ci;
11743     RgnHandle clipRgn;
11744 #ifndef GraphicsImportSetClip
11745     PyMac_PRECHECK(GraphicsImportSetClip);
11746 #endif
11747     if (!PyArg_ParseTuple(_args, "O&O&",
11748                           CmpInstObj_Convert, &ci,
11749                           ResObj_Convert, &clipRgn))
11750         return NULL;
11751     _rv = GraphicsImportSetClip(ci,
11752                                 clipRgn);
11753     _res = Py_BuildValue("l",
11754                          _rv);
11755     return _res;
11756 }
11757
11758 static PyObject *Qt_GraphicsImportGetClip(PyObject *_self, PyObject *_args)
11759 {
11760     PyObject *_res = NULL;
11761     ComponentResult _rv;
11762     GraphicsImportComponent ci;
11763     RgnHandle clipRgn;
11764 #ifndef GraphicsImportGetClip
11765     PyMac_PRECHECK(GraphicsImportGetClip);
11766 #endif
11767     if (!PyArg_ParseTuple(_args, "O&",
11768                           CmpInstObj_Convert, &ci))
11769         return NULL;
11770     _rv = GraphicsImportGetClip(ci,
11771                                 &clipRgn);
11772     _res = Py_BuildValue("lO&",
11773                          _rv,
11774                          ResObj_New, clipRgn);
11775     return _res;
11776 }
11777
11778 static PyObject *Qt_GraphicsImportSetSourceRect(PyObject *_self, PyObject *_args)
11779 {
11780     PyObject *_res = NULL;
11781     ComponentResult _rv;
11782     GraphicsImportComponent ci;
11783     Rect sourceRect;
11784 #ifndef GraphicsImportSetSourceRect
11785     PyMac_PRECHECK(GraphicsImportSetSourceRect);
11786 #endif
11787     if (!PyArg_ParseTuple(_args, "O&O&",
11788                           CmpInstObj_Convert, &ci,
11789                           PyMac_GetRect, &sourceRect))
11790         return NULL;
11791     _rv = GraphicsImportSetSourceRect(ci,
11792                                       &sourceRect);
11793     _res = Py_BuildValue("l",
11794                          _rv);
11795     return _res;
11796 }
11797
11798 static PyObject *Qt_GraphicsImportGetSourceRect(PyObject *_self, PyObject *_args)
11799 {
11800     PyObject *_res = NULL;
11801     ComponentResult _rv;
11802     GraphicsImportComponent ci;
11803     Rect sourceRect;
11804 #ifndef GraphicsImportGetSourceRect
11805     PyMac_PRECHECK(GraphicsImportGetSourceRect);
11806 #endif
11807     if (!PyArg_ParseTuple(_args, "O&",
11808                           CmpInstObj_Convert, &ci))
11809         return NULL;
11810     _rv = GraphicsImportGetSourceRect(ci,
11811                                       &sourceRect);
11812     _res = Py_BuildValue("lO&",
11813                          _rv,
11814                          PyMac_BuildRect, &sourceRect);
11815     return _res;
11816 }
11817
11818 static PyObject *Qt_GraphicsImportGetNaturalBounds(PyObject *_self, PyObject *_args)
11819 {
11820     PyObject *_res = NULL;
11821     ComponentResult _rv;
11822     GraphicsImportComponent ci;
11823     Rect naturalBounds;
11824 #ifndef GraphicsImportGetNaturalBounds
11825     PyMac_PRECHECK(GraphicsImportGetNaturalBounds);
11826 #endif
11827     if (!PyArg_ParseTuple(_args, "O&",
11828                           CmpInstObj_Convert, &ci))
11829         return NULL;
11830     _rv = GraphicsImportGetNaturalBounds(ci,
11831                                          &naturalBounds);
11832     _res = Py_BuildValue("lO&",
11833                          _rv,
11834                          PyMac_BuildRect, &naturalBounds);
11835     return _res;
11836 }
11837
11838 static PyObject *Qt_GraphicsImportDraw(PyObject *_self, PyObject *_args)
11839 {
11840     PyObject *_res = NULL;
11841     ComponentResult _rv;
11842     GraphicsImportComponent ci;
11843 #ifndef GraphicsImportDraw
11844     PyMac_PRECHECK(GraphicsImportDraw);
11845 #endif
11846     if (!PyArg_ParseTuple(_args, "O&",
11847                           CmpInstObj_Convert, &ci))
11848         return NULL;
11849     _rv = GraphicsImportDraw(ci);
11850     _res = Py_BuildValue("l",
11851                          _rv);
11852     return _res;
11853 }
11854
11855 static PyObject *Qt_GraphicsImportSetGWorld(PyObject *_self, PyObject *_args)
11856 {
11857     PyObject *_res = NULL;
11858     ComponentResult _rv;
11859     GraphicsImportComponent ci;
11860     CGrafPtr port;
11861     GDHandle gd;
11862 #ifndef GraphicsImportSetGWorld
11863     PyMac_PRECHECK(GraphicsImportSetGWorld);
11864 #endif
11865     if (!PyArg_ParseTuple(_args, "O&O&O&",
11866                           CmpInstObj_Convert, &ci,
11867                           GrafObj_Convert, &port,
11868                           OptResObj_Convert, &gd))
11869         return NULL;
11870     _rv = GraphicsImportSetGWorld(ci,
11871                                   port,
11872                                   gd);
11873     _res = Py_BuildValue("l",
11874                          _rv);
11875     return _res;
11876 }
11877
11878 static PyObject *Qt_GraphicsImportGetGWorld(PyObject *_self, PyObject *_args)
11879 {
11880     PyObject *_res = NULL;
11881     ComponentResult _rv;
11882     GraphicsImportComponent ci;
11883     CGrafPtr port;
11884     GDHandle gd;
11885 #ifndef GraphicsImportGetGWorld
11886     PyMac_PRECHECK(GraphicsImportGetGWorld);
11887 #endif
11888     if (!PyArg_ParseTuple(_args, "O&",
11889                           CmpInstObj_Convert, &ci))
11890         return NULL;
11891     _rv = GraphicsImportGetGWorld(ci,
11892                                   &port,
11893                                   &gd);
11894     _res = Py_BuildValue("lO&O&",
11895                          _rv,
11896                          GrafObj_New, port,
11897                          OptResObj_New, gd);
11898     return _res;
11899 }
11900
11901 static PyObject *Qt_GraphicsImportSetBoundsRect(PyObject *_self, PyObject *_args)
11902 {
11903     PyObject *_res = NULL;
11904     ComponentResult _rv;
11905     GraphicsImportComponent ci;
11906     Rect bounds;
11907 #ifndef GraphicsImportSetBoundsRect
11908     PyMac_PRECHECK(GraphicsImportSetBoundsRect);
11909 #endif
11910     if (!PyArg_ParseTuple(_args, "O&O&",
11911                           CmpInstObj_Convert, &ci,
11912                           PyMac_GetRect, &bounds))
11913         return NULL;
11914     _rv = GraphicsImportSetBoundsRect(ci,
11915                                       &bounds);
11916     _res = Py_BuildValue("l",
11917                          _rv);
11918     return _res;
11919 }
11920
11921 static PyObject *Qt_GraphicsImportGetBoundsRect(PyObject *_self, PyObject *_args)
11922 {
11923     PyObject *_res = NULL;
11924     ComponentResult _rv;
11925     GraphicsImportComponent ci;
11926     Rect bounds;
11927 #ifndef GraphicsImportGetBoundsRect
11928     PyMac_PRECHECK(GraphicsImportGetBoundsRect);
11929 #endif
11930     if (!PyArg_ParseTuple(_args, "O&",
11931                           CmpInstObj_Convert, &ci))
11932         return NULL;
11933     _rv = GraphicsImportGetBoundsRect(ci,
11934                                       &bounds);
11935     _res = Py_BuildValue("lO&",
11936                          _rv,
11937                          PyMac_BuildRect, &bounds);
11938     return _res;
11939 }
11940
11941 static PyObject *Qt_GraphicsImportSaveAsPicture(PyObject *_self, PyObject *_args)
11942 {
11943     PyObject *_res = NULL;
11944     ComponentResult _rv;
11945     GraphicsImportComponent ci;
11946     FSSpec fss;
11947     ScriptCode scriptTag;
11948 #ifndef GraphicsImportSaveAsPicture
11949     PyMac_PRECHECK(GraphicsImportSaveAsPicture);
11950 #endif
11951     if (!PyArg_ParseTuple(_args, "O&O&h",
11952                           CmpInstObj_Convert, &ci,
11953                           PyMac_GetFSSpec, &fss,
11954                           &scriptTag))
11955         return NULL;
11956     _rv = GraphicsImportSaveAsPicture(ci,
11957                                       &fss,
11958                                       scriptTag);
11959     _res = Py_BuildValue("l",
11960                          _rv);
11961     return _res;
11962 }
11963
11964 static PyObject *Qt_GraphicsImportSetGraphicsMode(PyObject *_self, PyObject *_args)
11965 {
11966     PyObject *_res = NULL;
11967     ComponentResult _rv;
11968     GraphicsImportComponent ci;
11969     long graphicsMode;
11970     RGBColor opColor;
11971 #ifndef GraphicsImportSetGraphicsMode
11972     PyMac_PRECHECK(GraphicsImportSetGraphicsMode);
11973 #endif
11974     if (!PyArg_ParseTuple(_args, "O&lO&",
11975                           CmpInstObj_Convert, &ci,
11976                           &graphicsMode,
11977                           QdRGB_Convert, &opColor))
11978         return NULL;
11979     _rv = GraphicsImportSetGraphicsMode(ci,
11980                                         graphicsMode,
11981                                         &opColor);
11982     _res = Py_BuildValue("l",
11983                          _rv);
11984     return _res;
11985 }
11986
11987 static PyObject *Qt_GraphicsImportGetGraphicsMode(PyObject *_self, PyObject *_args)
11988 {
11989     PyObject *_res = NULL;
11990     ComponentResult _rv;
11991     GraphicsImportComponent ci;
11992     long graphicsMode;
11993     RGBColor opColor;
11994 #ifndef GraphicsImportGetGraphicsMode
11995     PyMac_PRECHECK(GraphicsImportGetGraphicsMode);
11996 #endif
11997     if (!PyArg_ParseTuple(_args, "O&",
11998                           CmpInstObj_Convert, &ci))
11999         return NULL;
12000     _rv = GraphicsImportGetGraphicsMode(ci,
12001                                         &graphicsMode,
12002                                         &opColor);
12003     _res = Py_BuildValue("llO&",
12004                          _rv,
12005                          graphicsMode,
12006                          QdRGB_New, &opColor);
12007     return _res;
12008 }
12009
12010 static PyObject *Qt_GraphicsImportSetQuality(PyObject *_self, PyObject *_args)
12011 {
12012     PyObject *_res = NULL;
12013     ComponentResult _rv;
12014     GraphicsImportComponent ci;
12015     CodecQ quality;
12016 #ifndef GraphicsImportSetQuality
12017     PyMac_PRECHECK(GraphicsImportSetQuality);
12018 #endif
12019     if (!PyArg_ParseTuple(_args, "O&l",
12020                           CmpInstObj_Convert, &ci,
12021                           &quality))
12022         return NULL;
12023     _rv = GraphicsImportSetQuality(ci,
12024                                    quality);
12025     _res = Py_BuildValue("l",
12026                          _rv);
12027     return _res;
12028 }
12029
12030 static PyObject *Qt_GraphicsImportGetQuality(PyObject *_self, PyObject *_args)
12031 {
12032     PyObject *_res = NULL;
12033     ComponentResult _rv;
12034     GraphicsImportComponent ci;
12035     CodecQ quality;
12036 #ifndef GraphicsImportGetQuality
12037     PyMac_PRECHECK(GraphicsImportGetQuality);
12038 #endif
12039     if (!PyArg_ParseTuple(_args, "O&",
12040                           CmpInstObj_Convert, &ci))
12041         return NULL;
12042     _rv = GraphicsImportGetQuality(ci,
12043                                    &quality);
12044     _res = Py_BuildValue("ll",
12045                          _rv,
12046                          quality);
12047     return _res;
12048 }
12049
12050 static PyObject *Qt_GraphicsImportSaveAsQuickTimeImageFile(PyObject *_self, PyObject *_args)
12051 {
12052     PyObject *_res = NULL;
12053     ComponentResult _rv;
12054     GraphicsImportComponent ci;
12055     FSSpec fss;
12056     ScriptCode scriptTag;
12057 #ifndef GraphicsImportSaveAsQuickTimeImageFile
12058     PyMac_PRECHECK(GraphicsImportSaveAsQuickTimeImageFile);
12059 #endif
12060     if (!PyArg_ParseTuple(_args, "O&O&h",
12061                           CmpInstObj_Convert, &ci,
12062                           PyMac_GetFSSpec, &fss,
12063                           &scriptTag))
12064         return NULL;
12065     _rv = GraphicsImportSaveAsQuickTimeImageFile(ci,
12066                                                  &fss,
12067                                                  scriptTag);
12068     _res = Py_BuildValue("l",
12069                          _rv);
12070     return _res;
12071 }
12072
12073 static PyObject *Qt_GraphicsImportSetDataReferenceOffsetAndLimit(PyObject *_self, PyObject *_args)
12074 {
12075     PyObject *_res = NULL;
12076     ComponentResult _rv;
12077     GraphicsImportComponent ci;
12078     unsigned long offset;
12079     unsigned long limit;
12080 #ifndef GraphicsImportSetDataReferenceOffsetAndLimit
12081     PyMac_PRECHECK(GraphicsImportSetDataReferenceOffsetAndLimit);
12082 #endif
12083     if (!PyArg_ParseTuple(_args, "O&ll",
12084                           CmpInstObj_Convert, &ci,
12085                           &offset,
12086                           &limit))
12087         return NULL;
12088     _rv = GraphicsImportSetDataReferenceOffsetAndLimit(ci,
12089                                                        offset,
12090                                                        limit);
12091     _res = Py_BuildValue("l",
12092                          _rv);
12093     return _res;
12094 }
12095
12096 static PyObject *Qt_GraphicsImportGetDataReferenceOffsetAndLimit(PyObject *_self, PyObject *_args)
12097 {
12098     PyObject *_res = NULL;
12099     ComponentResult _rv;
12100     GraphicsImportComponent ci;
12101     unsigned long offset;
12102     unsigned long limit;
12103 #ifndef GraphicsImportGetDataReferenceOffsetAndLimit
12104     PyMac_PRECHECK(GraphicsImportGetDataReferenceOffsetAndLimit);
12105 #endif
12106     if (!PyArg_ParseTuple(_args, "O&",
12107                           CmpInstObj_Convert, &ci))
12108         return NULL;
12109     _rv = GraphicsImportGetDataReferenceOffsetAndLimit(ci,
12110                                                        &offset,
12111                                                        &limit);
12112     _res = Py_BuildValue("lll",
12113                          _rv,
12114                          offset,
12115                          limit);
12116     return _res;
12117 }
12118
12119 static PyObject *Qt_GraphicsImportGetAliasedDataReference(PyObject *_self, PyObject *_args)
12120 {
12121     PyObject *_res = NULL;
12122     ComponentResult _rv;
12123     GraphicsImportComponent ci;
12124     Handle dataRef;
12125     OSType dataRefType;
12126 #ifndef GraphicsImportGetAliasedDataReference
12127     PyMac_PRECHECK(GraphicsImportGetAliasedDataReference);
12128 #endif
12129     if (!PyArg_ParseTuple(_args, "O&",
12130                           CmpInstObj_Convert, &ci))
12131         return NULL;
12132     _rv = GraphicsImportGetAliasedDataReference(ci,
12133                                                 &dataRef,
12134                                                 &dataRefType);
12135     _res = Py_BuildValue("lO&O&",
12136                          _rv,
12137                          ResObj_New, dataRef,
12138                          PyMac_BuildOSType, dataRefType);
12139     return _res;
12140 }
12141
12142 static PyObject *Qt_GraphicsImportValidate(PyObject *_self, PyObject *_args)
12143 {
12144     PyObject *_res = NULL;
12145     ComponentResult _rv;
12146     GraphicsImportComponent ci;
12147     Boolean valid;
12148 #ifndef GraphicsImportValidate
12149     PyMac_PRECHECK(GraphicsImportValidate);
12150 #endif
12151     if (!PyArg_ParseTuple(_args, "O&",
12152                           CmpInstObj_Convert, &ci))
12153         return NULL;
12154     _rv = GraphicsImportValidate(ci,
12155                                  &valid);
12156     _res = Py_BuildValue("lb",
12157                          _rv,
12158                          valid);
12159     return _res;
12160 }
12161
12162 static PyObject *Qt_GraphicsImportGetMetaData(PyObject *_self, PyObject *_args)
12163 {
12164     PyObject *_res = NULL;
12165     ComponentResult _rv;
12166     GraphicsImportComponent ci;
12167     void * userData;
12168 #ifndef GraphicsImportGetMetaData
12169     PyMac_PRECHECK(GraphicsImportGetMetaData);
12170 #endif
12171     if (!PyArg_ParseTuple(_args, "O&s",
12172                           CmpInstObj_Convert, &ci,
12173                           &userData))
12174         return NULL;
12175     _rv = GraphicsImportGetMetaData(ci,
12176                                     userData);
12177     _res = Py_BuildValue("l",
12178                          _rv);
12179     return _res;
12180 }
12181
12182 static PyObject *Qt_GraphicsImportGetMIMETypeList(PyObject *_self, PyObject *_args)
12183 {
12184     PyObject *_res = NULL;
12185     ComponentResult _rv;
12186     GraphicsImportComponent ci;
12187     void * qtAtomContainerPtr;
12188 #ifndef GraphicsImportGetMIMETypeList
12189     PyMac_PRECHECK(GraphicsImportGetMIMETypeList);
12190 #endif
12191     if (!PyArg_ParseTuple(_args, "O&s",
12192                           CmpInstObj_Convert, &ci,
12193                           &qtAtomContainerPtr))
12194         return NULL;
12195     _rv = GraphicsImportGetMIMETypeList(ci,
12196                                         qtAtomContainerPtr);
12197     _res = Py_BuildValue("l",
12198                          _rv);
12199     return _res;
12200 }
12201
12202 static PyObject *Qt_GraphicsImportDoesDrawAllPixels(PyObject *_self, PyObject *_args)
12203 {
12204     PyObject *_res = NULL;
12205     ComponentResult _rv;
12206     GraphicsImportComponent ci;
12207     short drawsAllPixels;
12208 #ifndef GraphicsImportDoesDrawAllPixels
12209     PyMac_PRECHECK(GraphicsImportDoesDrawAllPixels);
12210 #endif
12211     if (!PyArg_ParseTuple(_args, "O&",
12212                           CmpInstObj_Convert, &ci))
12213         return NULL;
12214     _rv = GraphicsImportDoesDrawAllPixels(ci,
12215                                           &drawsAllPixels);
12216     _res = Py_BuildValue("lh",
12217                          _rv,
12218                          drawsAllPixels);
12219     return _res;
12220 }
12221
12222 static PyObject *Qt_GraphicsImportGetAsPicture(PyObject *_self, PyObject *_args)
12223 {
12224     PyObject *_res = NULL;
12225     ComponentResult _rv;
12226     GraphicsImportComponent ci;
12227     PicHandle picture;
12228 #ifndef GraphicsImportGetAsPicture
12229     PyMac_PRECHECK(GraphicsImportGetAsPicture);
12230 #endif
12231     if (!PyArg_ParseTuple(_args, "O&",
12232                           CmpInstObj_Convert, &ci))
12233         return NULL;
12234     _rv = GraphicsImportGetAsPicture(ci,
12235                                      &picture);
12236     _res = Py_BuildValue("lO&",
12237                          _rv,
12238                          ResObj_New, picture);
12239     return _res;
12240 }
12241
12242 static PyObject *Qt_GraphicsImportExportImageFile(PyObject *_self, PyObject *_args)
12243 {
12244     PyObject *_res = NULL;
12245     ComponentResult _rv;
12246     GraphicsImportComponent ci;
12247     OSType fileType;
12248     OSType fileCreator;
12249     FSSpec fss;
12250     ScriptCode scriptTag;
12251 #ifndef GraphicsImportExportImageFile
12252     PyMac_PRECHECK(GraphicsImportExportImageFile);
12253 #endif
12254     if (!PyArg_ParseTuple(_args, "O&O&O&O&h",
12255                           CmpInstObj_Convert, &ci,
12256                           PyMac_GetOSType, &fileType,
12257                           PyMac_GetOSType, &fileCreator,
12258                           PyMac_GetFSSpec, &fss,
12259                           &scriptTag))
12260         return NULL;
12261     _rv = GraphicsImportExportImageFile(ci,
12262                                         fileType,
12263                                         fileCreator,
12264                                         &fss,
12265                                         scriptTag);
12266     _res = Py_BuildValue("l",
12267                          _rv);
12268     return _res;
12269 }
12270
12271 static PyObject *Qt_GraphicsImportGetExportImageTypeList(PyObject *_self, PyObject *_args)
12272 {
12273     PyObject *_res = NULL;
12274     ComponentResult _rv;
12275     GraphicsImportComponent ci;
12276     void * qtAtomContainerPtr;
12277 #ifndef GraphicsImportGetExportImageTypeList
12278     PyMac_PRECHECK(GraphicsImportGetExportImageTypeList);
12279 #endif
12280     if (!PyArg_ParseTuple(_args, "O&s",
12281                           CmpInstObj_Convert, &ci,
12282                           &qtAtomContainerPtr))
12283         return NULL;
12284     _rv = GraphicsImportGetExportImageTypeList(ci,
12285                                                qtAtomContainerPtr);
12286     _res = Py_BuildValue("l",
12287                          _rv);
12288     return _res;
12289 }
12290
12291 static PyObject *Qt_GraphicsImportGetExportSettingsAsAtomContainer(PyObject *_self, PyObject *_args)
12292 {
12293     PyObject *_res = NULL;
12294     ComponentResult _rv;
12295     GraphicsImportComponent ci;
12296     void * qtAtomContainerPtr;
12297 #ifndef GraphicsImportGetExportSettingsAsAtomContainer
12298     PyMac_PRECHECK(GraphicsImportGetExportSettingsAsAtomContainer);
12299 #endif
12300     if (!PyArg_ParseTuple(_args, "O&s",
12301                           CmpInstObj_Convert, &ci,
12302                           &qtAtomContainerPtr))
12303         return NULL;
12304     _rv = GraphicsImportGetExportSettingsAsAtomContainer(ci,
12305                                                          qtAtomContainerPtr);
12306     _res = Py_BuildValue("l",
12307                          _rv);
12308     return _res;
12309 }
12310
12311 static PyObject *Qt_GraphicsImportSetExportSettingsFromAtomContainer(PyObject *_self, PyObject *_args)
12312 {
12313     PyObject *_res = NULL;
12314     ComponentResult _rv;
12315     GraphicsImportComponent ci;
12316     void * qtAtomContainer;
12317 #ifndef GraphicsImportSetExportSettingsFromAtomContainer
12318     PyMac_PRECHECK(GraphicsImportSetExportSettingsFromAtomContainer);
12319 #endif
12320     if (!PyArg_ParseTuple(_args, "O&s",
12321                           CmpInstObj_Convert, &ci,
12322                           &qtAtomContainer))
12323         return NULL;
12324     _rv = GraphicsImportSetExportSettingsFromAtomContainer(ci,
12325                                                            qtAtomContainer);
12326     _res = Py_BuildValue("l",
12327                          _rv);
12328     return _res;
12329 }
12330
12331 static PyObject *Qt_GraphicsImportGetImageCount(PyObject *_self, PyObject *_args)
12332 {
12333     PyObject *_res = NULL;
12334     ComponentResult _rv;
12335     GraphicsImportComponent ci;
12336     unsigned long imageCount;
12337 #ifndef GraphicsImportGetImageCount
12338     PyMac_PRECHECK(GraphicsImportGetImageCount);
12339 #endif
12340     if (!PyArg_ParseTuple(_args, "O&",
12341                           CmpInstObj_Convert, &ci))
12342         return NULL;
12343     _rv = GraphicsImportGetImageCount(ci,
12344                                       &imageCount);
12345     _res = Py_BuildValue("ll",
12346                          _rv,
12347                          imageCount);
12348     return _res;
12349 }
12350
12351 static PyObject *Qt_GraphicsImportSetImageIndex(PyObject *_self, PyObject *_args)
12352 {
12353     PyObject *_res = NULL;
12354     ComponentResult _rv;
12355     GraphicsImportComponent ci;
12356     unsigned long imageIndex;
12357 #ifndef GraphicsImportSetImageIndex
12358     PyMac_PRECHECK(GraphicsImportSetImageIndex);
12359 #endif
12360     if (!PyArg_ParseTuple(_args, "O&l",
12361                           CmpInstObj_Convert, &ci,
12362                           &imageIndex))
12363         return NULL;
12364     _rv = GraphicsImportSetImageIndex(ci,
12365                                       imageIndex);
12366     _res = Py_BuildValue("l",
12367                          _rv);
12368     return _res;
12369 }
12370
12371 static PyObject *Qt_GraphicsImportGetImageIndex(PyObject *_self, PyObject *_args)
12372 {
12373     PyObject *_res = NULL;
12374     ComponentResult _rv;
12375     GraphicsImportComponent ci;
12376     unsigned long imageIndex;
12377 #ifndef GraphicsImportGetImageIndex
12378     PyMac_PRECHECK(GraphicsImportGetImageIndex);
12379 #endif
12380     if (!PyArg_ParseTuple(_args, "O&",
12381                           CmpInstObj_Convert, &ci))
12382         return NULL;
12383     _rv = GraphicsImportGetImageIndex(ci,
12384                                       &imageIndex);
12385     _res = Py_BuildValue("ll",
12386                          _rv,
12387                          imageIndex);
12388     return _res;
12389 }
12390
12391 static PyObject *Qt_GraphicsImportGetDataOffsetAndSize64(PyObject *_self, PyObject *_args)
12392 {
12393     PyObject *_res = NULL;
12394     ComponentResult _rv;
12395     GraphicsImportComponent ci;
12396     wide offset;
12397     wide size;
12398 #ifndef GraphicsImportGetDataOffsetAndSize64
12399     PyMac_PRECHECK(GraphicsImportGetDataOffsetAndSize64);
12400 #endif
12401     if (!PyArg_ParseTuple(_args, "O&",
12402                           CmpInstObj_Convert, &ci))
12403         return NULL;
12404     _rv = GraphicsImportGetDataOffsetAndSize64(ci,
12405                                                &offset,
12406                                                &size);
12407     _res = Py_BuildValue("lO&O&",
12408                          _rv,
12409                          PyMac_Buildwide, offset,
12410                          PyMac_Buildwide, size);
12411     return _res;
12412 }
12413
12414 static PyObject *Qt_GraphicsImportReadData64(PyObject *_self, PyObject *_args)
12415 {
12416     PyObject *_res = NULL;
12417     ComponentResult _rv;
12418     GraphicsImportComponent ci;
12419     void * dataPtr;
12420     wide dataOffset;
12421     unsigned long dataSize;
12422 #ifndef GraphicsImportReadData64
12423     PyMac_PRECHECK(GraphicsImportReadData64);
12424 #endif
12425     if (!PyArg_ParseTuple(_args, "O&sO&l",
12426                           CmpInstObj_Convert, &ci,
12427                           &dataPtr,
12428                           PyMac_Getwide, &dataOffset,
12429                           &dataSize))
12430         return NULL;
12431     _rv = GraphicsImportReadData64(ci,
12432                                    dataPtr,
12433                                    &dataOffset,
12434                                    dataSize);
12435     _res = Py_BuildValue("l",
12436                          _rv);
12437     return _res;
12438 }
12439
12440 static PyObject *Qt_GraphicsImportSetDataReferenceOffsetAndLimit64(PyObject *_self, PyObject *_args)
12441 {
12442     PyObject *_res = NULL;
12443     ComponentResult _rv;
12444     GraphicsImportComponent ci;
12445     wide offset;
12446     wide limit;
12447 #ifndef GraphicsImportSetDataReferenceOffsetAndLimit64
12448     PyMac_PRECHECK(GraphicsImportSetDataReferenceOffsetAndLimit64);
12449 #endif
12450     if (!PyArg_ParseTuple(_args, "O&O&O&",
12451                           CmpInstObj_Convert, &ci,
12452                           PyMac_Getwide, &offset,
12453                           PyMac_Getwide, &limit))
12454         return NULL;
12455     _rv = GraphicsImportSetDataReferenceOffsetAndLimit64(ci,
12456                                                          &offset,
12457                                                          &limit);
12458     _res = Py_BuildValue("l",
12459                          _rv);
12460     return _res;
12461 }
12462
12463 static PyObject *Qt_GraphicsImportGetDataReferenceOffsetAndLimit64(PyObject *_self, PyObject *_args)
12464 {
12465     PyObject *_res = NULL;
12466     ComponentResult _rv;
12467     GraphicsImportComponent ci;
12468     wide offset;
12469     wide limit;
12470 #ifndef GraphicsImportGetDataReferenceOffsetAndLimit64
12471     PyMac_PRECHECK(GraphicsImportGetDataReferenceOffsetAndLimit64);
12472 #endif
12473     if (!PyArg_ParseTuple(_args, "O&",
12474                           CmpInstObj_Convert, &ci))
12475         return NULL;
12476     _rv = GraphicsImportGetDataReferenceOffsetAndLimit64(ci,
12477                                                          &offset,
12478                                                          &limit);
12479     _res = Py_BuildValue("lO&O&",
12480                          _rv,
12481                          PyMac_Buildwide, offset,
12482                          PyMac_Buildwide, limit);
12483     return _res;
12484 }
12485
12486 static PyObject *Qt_GraphicsImportGetDefaultClip(PyObject *_self, PyObject *_args)
12487 {
12488     PyObject *_res = NULL;
12489     ComponentResult _rv;
12490     GraphicsImportComponent ci;
12491     RgnHandle defaultRgn;
12492 #ifndef GraphicsImportGetDefaultClip
12493     PyMac_PRECHECK(GraphicsImportGetDefaultClip);
12494 #endif
12495     if (!PyArg_ParseTuple(_args, "O&",
12496                           CmpInstObj_Convert, &ci))
12497         return NULL;
12498     _rv = GraphicsImportGetDefaultClip(ci,
12499                                        &defaultRgn);
12500     _res = Py_BuildValue("lO&",
12501                          _rv,
12502                          ResObj_New, defaultRgn);
12503     return _res;
12504 }
12505
12506 static PyObject *Qt_GraphicsImportGetDefaultGraphicsMode(PyObject *_self, PyObject *_args)
12507 {
12508     PyObject *_res = NULL;
12509     ComponentResult _rv;
12510     GraphicsImportComponent ci;
12511     long defaultGraphicsMode;
12512     RGBColor defaultOpColor;
12513 #ifndef GraphicsImportGetDefaultGraphicsMode
12514     PyMac_PRECHECK(GraphicsImportGetDefaultGraphicsMode);
12515 #endif
12516     if (!PyArg_ParseTuple(_args, "O&",
12517                           CmpInstObj_Convert, &ci))
12518         return NULL;
12519     _rv = GraphicsImportGetDefaultGraphicsMode(ci,
12520                                                &defaultGraphicsMode,
12521                                                &defaultOpColor);
12522     _res = Py_BuildValue("llO&",
12523                          _rv,
12524                          defaultGraphicsMode,
12525                          QdRGB_New, &defaultOpColor);
12526     return _res;
12527 }
12528
12529 static PyObject *Qt_GraphicsImportGetDefaultSourceRect(PyObject *_self, PyObject *_args)
12530 {
12531     PyObject *_res = NULL;
12532     ComponentResult _rv;
12533     GraphicsImportComponent ci;
12534     Rect defaultSourceRect;
12535 #ifndef GraphicsImportGetDefaultSourceRect
12536     PyMac_PRECHECK(GraphicsImportGetDefaultSourceRect);
12537 #endif
12538     if (!PyArg_ParseTuple(_args, "O&",
12539                           CmpInstObj_Convert, &ci))
12540         return NULL;
12541     _rv = GraphicsImportGetDefaultSourceRect(ci,
12542                                              &defaultSourceRect);
12543     _res = Py_BuildValue("lO&",
12544                          _rv,
12545                          PyMac_BuildRect, &defaultSourceRect);
12546     return _res;
12547 }
12548
12549 static PyObject *Qt_GraphicsImportGetColorSyncProfile(PyObject *_self, PyObject *_args)
12550 {
12551     PyObject *_res = NULL;
12552     ComponentResult _rv;
12553     GraphicsImportComponent ci;
12554     Handle profile;
12555 #ifndef GraphicsImportGetColorSyncProfile
12556     PyMac_PRECHECK(GraphicsImportGetColorSyncProfile);
12557 #endif
12558     if (!PyArg_ParseTuple(_args, "O&",
12559                           CmpInstObj_Convert, &ci))
12560         return NULL;
12561     _rv = GraphicsImportGetColorSyncProfile(ci,
12562                                             &profile);
12563     _res = Py_BuildValue("lO&",
12564                          _rv,
12565                          ResObj_New, profile);
12566     return _res;
12567 }
12568
12569 static PyObject *Qt_GraphicsImportSetDestRect(PyObject *_self, PyObject *_args)
12570 {
12571     PyObject *_res = NULL;
12572     ComponentResult _rv;
12573     GraphicsImportComponent ci;
12574     Rect destRect;
12575 #ifndef GraphicsImportSetDestRect
12576     PyMac_PRECHECK(GraphicsImportSetDestRect);
12577 #endif
12578     if (!PyArg_ParseTuple(_args, "O&O&",
12579                           CmpInstObj_Convert, &ci,
12580                           PyMac_GetRect, &destRect))
12581         return NULL;
12582     _rv = GraphicsImportSetDestRect(ci,
12583                                     &destRect);
12584     _res = Py_BuildValue("l",
12585                          _rv);
12586     return _res;
12587 }
12588
12589 static PyObject *Qt_GraphicsImportGetDestRect(PyObject *_self, PyObject *_args)
12590 {
12591     PyObject *_res = NULL;
12592     ComponentResult _rv;
12593     GraphicsImportComponent ci;
12594     Rect destRect;
12595 #ifndef GraphicsImportGetDestRect
12596     PyMac_PRECHECK(GraphicsImportGetDestRect);
12597 #endif
12598     if (!PyArg_ParseTuple(_args, "O&",
12599                           CmpInstObj_Convert, &ci))
12600         return NULL;
12601     _rv = GraphicsImportGetDestRect(ci,
12602                                     &destRect);
12603     _res = Py_BuildValue("lO&",
12604                          _rv,
12605                          PyMac_BuildRect, &destRect);
12606     return _res;
12607 }
12608
12609 static PyObject *Qt_GraphicsImportSetFlags(PyObject *_self, PyObject *_args)
12610 {
12611     PyObject *_res = NULL;
12612     ComponentResult _rv;
12613     GraphicsImportComponent ci;
12614     long flags;
12615 #ifndef GraphicsImportSetFlags
12616     PyMac_PRECHECK(GraphicsImportSetFlags);
12617 #endif
12618     if (!PyArg_ParseTuple(_args, "O&l",
12619                           CmpInstObj_Convert, &ci,
12620                           &flags))
12621         return NULL;
12622     _rv = GraphicsImportSetFlags(ci,
12623                                  flags);
12624     _res = Py_BuildValue("l",
12625                          _rv);
12626     return _res;
12627 }
12628
12629 static PyObject *Qt_GraphicsImportGetFlags(PyObject *_self, PyObject *_args)
12630 {
12631     PyObject *_res = NULL;
12632     ComponentResult _rv;
12633     GraphicsImportComponent ci;
12634     long flags;
12635 #ifndef GraphicsImportGetFlags
12636     PyMac_PRECHECK(GraphicsImportGetFlags);
12637 #endif
12638     if (!PyArg_ParseTuple(_args, "O&",
12639                           CmpInstObj_Convert, &ci))
12640         return NULL;
12641     _rv = GraphicsImportGetFlags(ci,
12642                                  &flags);
12643     _res = Py_BuildValue("ll",
12644                          _rv,
12645                          flags);
12646     return _res;
12647 }
12648
12649 static PyObject *Qt_GraphicsImportGetBaseDataOffsetAndSize64(PyObject *_self, PyObject *_args)
12650 {
12651     PyObject *_res = NULL;
12652     ComponentResult _rv;
12653     GraphicsImportComponent ci;
12654     wide offset;
12655     wide size;
12656 #ifndef GraphicsImportGetBaseDataOffsetAndSize64
12657     PyMac_PRECHECK(GraphicsImportGetBaseDataOffsetAndSize64);
12658 #endif
12659     if (!PyArg_ParseTuple(_args, "O&",
12660                           CmpInstObj_Convert, &ci))
12661         return NULL;
12662     _rv = GraphicsImportGetBaseDataOffsetAndSize64(ci,
12663                                                    &offset,
12664                                                    &size);
12665     _res = Py_BuildValue("lO&O&",
12666                          _rv,
12667                          PyMac_Buildwide, offset,
12668                          PyMac_Buildwide, size);
12669     return _res;
12670 }
12671
12672 static PyObject *Qt_GraphicsImportSetImageIndexToThumbnail(PyObject *_self, PyObject *_args)
12673 {
12674     PyObject *_res = NULL;
12675     ComponentResult _rv;
12676     GraphicsImportComponent ci;
12677 #ifndef GraphicsImportSetImageIndexToThumbnail
12678     PyMac_PRECHECK(GraphicsImportSetImageIndexToThumbnail);
12679 #endif
12680     if (!PyArg_ParseTuple(_args, "O&",
12681                           CmpInstObj_Convert, &ci))
12682         return NULL;
12683     _rv = GraphicsImportSetImageIndexToThumbnail(ci);
12684     _res = Py_BuildValue("l",
12685                          _rv);
12686     return _res;
12687 }
12688
12689 static PyObject *Qt_GraphicsExportDoExport(PyObject *_self, PyObject *_args)
12690 {
12691     PyObject *_res = NULL;
12692     ComponentResult _rv;
12693     GraphicsExportComponent ci;
12694     unsigned long actualSizeWritten;
12695 #ifndef GraphicsExportDoExport
12696     PyMac_PRECHECK(GraphicsExportDoExport);
12697 #endif
12698     if (!PyArg_ParseTuple(_args, "O&",
12699                           CmpInstObj_Convert, &ci))
12700         return NULL;
12701     _rv = GraphicsExportDoExport(ci,
12702                                  &actualSizeWritten);
12703     _res = Py_BuildValue("ll",
12704                          _rv,
12705                          actualSizeWritten);
12706     return _res;
12707 }
12708
12709 static PyObject *Qt_GraphicsExportCanTranscode(PyObject *_self, PyObject *_args)
12710 {
12711     PyObject *_res = NULL;
12712     ComponentResult _rv;
12713     GraphicsExportComponent ci;
12714     Boolean canTranscode;
12715 #ifndef GraphicsExportCanTranscode
12716     PyMac_PRECHECK(GraphicsExportCanTranscode);
12717 #endif
12718     if (!PyArg_ParseTuple(_args, "O&",
12719                           CmpInstObj_Convert, &ci))
12720         return NULL;
12721     _rv = GraphicsExportCanTranscode(ci,
12722                                      &canTranscode);
12723     _res = Py_BuildValue("lb",
12724                          _rv,
12725                          canTranscode);
12726     return _res;
12727 }
12728
12729 static PyObject *Qt_GraphicsExportDoTranscode(PyObject *_self, PyObject *_args)
12730 {
12731     PyObject *_res = NULL;
12732     ComponentResult _rv;
12733     GraphicsExportComponent ci;
12734 #ifndef GraphicsExportDoTranscode
12735     PyMac_PRECHECK(GraphicsExportDoTranscode);
12736 #endif
12737     if (!PyArg_ParseTuple(_args, "O&",
12738                           CmpInstObj_Convert, &ci))
12739         return NULL;
12740     _rv = GraphicsExportDoTranscode(ci);
12741     _res = Py_BuildValue("l",
12742                          _rv);
12743     return _res;
12744 }
12745
12746 static PyObject *Qt_GraphicsExportCanUseCompressor(PyObject *_self, PyObject *_args)
12747 {
12748     PyObject *_res = NULL;
12749     ComponentResult _rv;
12750     GraphicsExportComponent ci;
12751     Boolean canUseCompressor;
12752     void * codecSettingsAtomContainerPtr;
12753 #ifndef GraphicsExportCanUseCompressor
12754     PyMac_PRECHECK(GraphicsExportCanUseCompressor);
12755 #endif
12756     if (!PyArg_ParseTuple(_args, "O&s",
12757                           CmpInstObj_Convert, &ci,
12758                           &codecSettingsAtomContainerPtr))
12759         return NULL;
12760     _rv = GraphicsExportCanUseCompressor(ci,
12761                                          &canUseCompressor,
12762                                          codecSettingsAtomContainerPtr);
12763     _res = Py_BuildValue("lb",
12764                          _rv,
12765                          canUseCompressor);
12766     return _res;
12767 }
12768
12769 static PyObject *Qt_GraphicsExportDoUseCompressor(PyObject *_self, PyObject *_args)
12770 {
12771     PyObject *_res = NULL;
12772     ComponentResult _rv;
12773     GraphicsExportComponent ci;
12774     void * codecSettingsAtomContainer;
12775     ImageDescriptionHandle outDesc;
12776 #ifndef GraphicsExportDoUseCompressor
12777     PyMac_PRECHECK(GraphicsExportDoUseCompressor);
12778 #endif
12779     if (!PyArg_ParseTuple(_args, "O&s",
12780                           CmpInstObj_Convert, &ci,
12781                           &codecSettingsAtomContainer))
12782         return NULL;
12783     _rv = GraphicsExportDoUseCompressor(ci,
12784                                         codecSettingsAtomContainer,
12785                                         &outDesc);
12786     _res = Py_BuildValue("lO&",
12787                          _rv,
12788                          ResObj_New, outDesc);
12789     return _res;
12790 }
12791
12792 static PyObject *Qt_GraphicsExportDoStandaloneExport(PyObject *_self, PyObject *_args)
12793 {
12794     PyObject *_res = NULL;
12795     ComponentResult _rv;
12796     GraphicsExportComponent ci;
12797 #ifndef GraphicsExportDoStandaloneExport
12798     PyMac_PRECHECK(GraphicsExportDoStandaloneExport);
12799 #endif
12800     if (!PyArg_ParseTuple(_args, "O&",
12801                           CmpInstObj_Convert, &ci))
12802         return NULL;
12803     _rv = GraphicsExportDoStandaloneExport(ci);
12804     _res = Py_BuildValue("l",
12805                          _rv);
12806     return _res;
12807 }
12808
12809 static PyObject *Qt_GraphicsExportGetDefaultFileTypeAndCreator(PyObject *_self, PyObject *_args)
12810 {
12811     PyObject *_res = NULL;
12812     ComponentResult _rv;
12813     GraphicsExportComponent ci;
12814     OSType fileType;
12815     OSType fileCreator;
12816 #ifndef GraphicsExportGetDefaultFileTypeAndCreator
12817     PyMac_PRECHECK(GraphicsExportGetDefaultFileTypeAndCreator);
12818 #endif
12819     if (!PyArg_ParseTuple(_args, "O&",
12820                           CmpInstObj_Convert, &ci))
12821         return NULL;
12822     _rv = GraphicsExportGetDefaultFileTypeAndCreator(ci,
12823                                                      &fileType,
12824                                                      &fileCreator);
12825     _res = Py_BuildValue("lO&O&",
12826                          _rv,
12827                          PyMac_BuildOSType, fileType,
12828                          PyMac_BuildOSType, fileCreator);
12829     return _res;
12830 }
12831
12832 static PyObject *Qt_GraphicsExportGetDefaultFileNameExtension(PyObject *_self, PyObject *_args)
12833 {
12834     PyObject *_res = NULL;
12835     ComponentResult _rv;
12836     GraphicsExportComponent ci;
12837     OSType fileNameExtension;
12838 #ifndef GraphicsExportGetDefaultFileNameExtension
12839     PyMac_PRECHECK(GraphicsExportGetDefaultFileNameExtension);
12840 #endif
12841     if (!PyArg_ParseTuple(_args, "O&",
12842                           CmpInstObj_Convert, &ci))
12843         return NULL;
12844     _rv = GraphicsExportGetDefaultFileNameExtension(ci,
12845                                                     &fileNameExtension);
12846     _res = Py_BuildValue("lO&",
12847                          _rv,
12848                          PyMac_BuildOSType, fileNameExtension);
12849     return _res;
12850 }
12851
12852 static PyObject *Qt_GraphicsExportGetMIMETypeList(PyObject *_self, PyObject *_args)
12853 {
12854     PyObject *_res = NULL;
12855     ComponentResult _rv;
12856     GraphicsExportComponent ci;
12857     void * qtAtomContainerPtr;
12858 #ifndef GraphicsExportGetMIMETypeList
12859     PyMac_PRECHECK(GraphicsExportGetMIMETypeList);
12860 #endif
12861     if (!PyArg_ParseTuple(_args, "O&s",
12862                           CmpInstObj_Convert, &ci,
12863                           &qtAtomContainerPtr))
12864         return NULL;
12865     _rv = GraphicsExportGetMIMETypeList(ci,
12866                                         qtAtomContainerPtr);
12867     _res = Py_BuildValue("l",
12868                          _rv);
12869     return _res;
12870 }
12871
12872 static PyObject *Qt_GraphicsExportSetSettingsFromAtomContainer(PyObject *_self, PyObject *_args)
12873 {
12874     PyObject *_res = NULL;
12875     ComponentResult _rv;
12876     GraphicsExportComponent ci;
12877     void * qtAtomContainer;
12878 #ifndef GraphicsExportSetSettingsFromAtomContainer
12879     PyMac_PRECHECK(GraphicsExportSetSettingsFromAtomContainer);
12880 #endif
12881     if (!PyArg_ParseTuple(_args, "O&s",
12882                           CmpInstObj_Convert, &ci,
12883                           &qtAtomContainer))
12884         return NULL;
12885     _rv = GraphicsExportSetSettingsFromAtomContainer(ci,
12886                                                      qtAtomContainer);
12887     _res = Py_BuildValue("l",
12888                          _rv);
12889     return _res;
12890 }
12891
12892 static PyObject *Qt_GraphicsExportGetSettingsAsAtomContainer(PyObject *_self, PyObject *_args)
12893 {
12894     PyObject *_res = NULL;
12895     ComponentResult _rv;
12896     GraphicsExportComponent ci;
12897     void * qtAtomContainerPtr;
12898 #ifndef GraphicsExportGetSettingsAsAtomContainer
12899     PyMac_PRECHECK(GraphicsExportGetSettingsAsAtomContainer);
12900 #endif
12901     if (!PyArg_ParseTuple(_args, "O&s",
12902                           CmpInstObj_Convert, &ci,
12903                           &qtAtomContainerPtr))
12904         return NULL;
12905     _rv = GraphicsExportGetSettingsAsAtomContainer(ci,
12906                                                    qtAtomContainerPtr);
12907     _res = Py_BuildValue("l",
12908                          _rv);
12909     return _res;
12910 }
12911
12912 static PyObject *Qt_GraphicsExportGetSettingsAsText(PyObject *_self, PyObject *_args)
12913 {
12914     PyObject *_res = NULL;
12915     ComponentResult _rv;
12916     GraphicsExportComponent ci;
12917     Handle theText;
12918 #ifndef GraphicsExportGetSettingsAsText
12919     PyMac_PRECHECK(GraphicsExportGetSettingsAsText);
12920 #endif
12921     if (!PyArg_ParseTuple(_args, "O&",
12922                           CmpInstObj_Convert, &ci))
12923         return NULL;
12924     _rv = GraphicsExportGetSettingsAsText(ci,
12925                                           &theText);
12926     _res = Py_BuildValue("lO&",
12927                          _rv,
12928                          ResObj_New, theText);
12929     return _res;
12930 }
12931
12932 static PyObject *Qt_GraphicsExportSetDontRecompress(PyObject *_self, PyObject *_args)
12933 {
12934     PyObject *_res = NULL;
12935     ComponentResult _rv;
12936     GraphicsExportComponent ci;
12937     Boolean dontRecompress;
12938 #ifndef GraphicsExportSetDontRecompress
12939     PyMac_PRECHECK(GraphicsExportSetDontRecompress);
12940 #endif
12941     if (!PyArg_ParseTuple(_args, "O&b",
12942                           CmpInstObj_Convert, &ci,
12943                           &dontRecompress))
12944         return NULL;
12945     _rv = GraphicsExportSetDontRecompress(ci,
12946                                           dontRecompress);
12947     _res = Py_BuildValue("l",
12948                          _rv);
12949     return _res;
12950 }
12951
12952 static PyObject *Qt_GraphicsExportGetDontRecompress(PyObject *_self, PyObject *_args)
12953 {
12954     PyObject *_res = NULL;
12955     ComponentResult _rv;
12956     GraphicsExportComponent ci;
12957     Boolean dontRecompress;
12958 #ifndef GraphicsExportGetDontRecompress
12959     PyMac_PRECHECK(GraphicsExportGetDontRecompress);
12960 #endif
12961     if (!PyArg_ParseTuple(_args, "O&",
12962                           CmpInstObj_Convert, &ci))
12963         return NULL;
12964     _rv = GraphicsExportGetDontRecompress(ci,
12965                                           &dontRecompress);
12966     _res = Py_BuildValue("lb",
12967                          _rv,
12968                          dontRecompress);
12969     return _res;
12970 }
12971
12972 static PyObject *Qt_GraphicsExportSetInterlaceStyle(PyObject *_self, PyObject *_args)
12973 {
12974     PyObject *_res = NULL;
12975     ComponentResult _rv;
12976     GraphicsExportComponent ci;
12977     unsigned long interlaceStyle;
12978 #ifndef GraphicsExportSetInterlaceStyle
12979     PyMac_PRECHECK(GraphicsExportSetInterlaceStyle);
12980 #endif
12981     if (!PyArg_ParseTuple(_args, "O&l",
12982                           CmpInstObj_Convert, &ci,
12983                           &interlaceStyle))
12984         return NULL;
12985     _rv = GraphicsExportSetInterlaceStyle(ci,
12986                                           interlaceStyle);
12987     _res = Py_BuildValue("l",
12988                          _rv);
12989     return _res;
12990 }
12991
12992 static PyObject *Qt_GraphicsExportGetInterlaceStyle(PyObject *_self, PyObject *_args)
12993 {
12994     PyObject *_res = NULL;
12995     ComponentResult _rv;
12996     GraphicsExportComponent ci;
12997     unsigned long interlaceStyle;
12998 #ifndef GraphicsExportGetInterlaceStyle
12999     PyMac_PRECHECK(GraphicsExportGetInterlaceStyle);
13000 #endif
13001     if (!PyArg_ParseTuple(_args, "O&",
13002                           CmpInstObj_Convert, &ci))
13003         return NULL;
13004     _rv = GraphicsExportGetInterlaceStyle(ci,
13005                                           &interlaceStyle);
13006     _res = Py_BuildValue("ll",
13007                          _rv,
13008                          interlaceStyle);
13009     return _res;
13010 }
13011
13012 static PyObject *Qt_GraphicsExportSetMetaData(PyObject *_self, PyObject *_args)
13013 {
13014     PyObject *_res = NULL;
13015     ComponentResult _rv;
13016     GraphicsExportComponent ci;
13017     void * userData;
13018 #ifndef GraphicsExportSetMetaData
13019     PyMac_PRECHECK(GraphicsExportSetMetaData);
13020 #endif
13021     if (!PyArg_ParseTuple(_args, "O&s",
13022                           CmpInstObj_Convert, &ci,
13023                           &userData))
13024         return NULL;
13025     _rv = GraphicsExportSetMetaData(ci,
13026                                     userData);
13027     _res = Py_BuildValue("l",
13028                          _rv);
13029     return _res;
13030 }
13031
13032 static PyObject *Qt_GraphicsExportGetMetaData(PyObject *_self, PyObject *_args)
13033 {
13034     PyObject *_res = NULL;
13035     ComponentResult _rv;
13036     GraphicsExportComponent ci;
13037     void * userData;
13038 #ifndef GraphicsExportGetMetaData
13039     PyMac_PRECHECK(GraphicsExportGetMetaData);
13040 #endif
13041     if (!PyArg_ParseTuple(_args, "O&s",
13042                           CmpInstObj_Convert, &ci,
13043                           &userData))
13044         return NULL;
13045     _rv = GraphicsExportGetMetaData(ci,
13046                                     userData);
13047     _res = Py_BuildValue("l",
13048                          _rv);
13049     return _res;
13050 }
13051
13052 static PyObject *Qt_GraphicsExportSetTargetDataSize(PyObject *_self, PyObject *_args)
13053 {
13054     PyObject *_res = NULL;
13055     ComponentResult _rv;
13056     GraphicsExportComponent ci;
13057     unsigned long targetDataSize;
13058 #ifndef GraphicsExportSetTargetDataSize
13059     PyMac_PRECHECK(GraphicsExportSetTargetDataSize);
13060 #endif
13061     if (!PyArg_ParseTuple(_args, "O&l",
13062                           CmpInstObj_Convert, &ci,
13063                           &targetDataSize))
13064         return NULL;
13065     _rv = GraphicsExportSetTargetDataSize(ci,
13066                                           targetDataSize);
13067     _res = Py_BuildValue("l",
13068                          _rv);
13069     return _res;
13070 }
13071
13072 static PyObject *Qt_GraphicsExportGetTargetDataSize(PyObject *_self, PyObject *_args)
13073 {
13074     PyObject *_res = NULL;
13075     ComponentResult _rv;
13076     GraphicsExportComponent ci;
13077     unsigned long targetDataSize;
13078 #ifndef GraphicsExportGetTargetDataSize
13079     PyMac_PRECHECK(GraphicsExportGetTargetDataSize);
13080 #endif
13081     if (!PyArg_ParseTuple(_args, "O&",
13082                           CmpInstObj_Convert, &ci))
13083         return NULL;
13084     _rv = GraphicsExportGetTargetDataSize(ci,
13085                                           &targetDataSize);
13086     _res = Py_BuildValue("ll",
13087                          _rv,
13088                          targetDataSize);
13089     return _res;
13090 }
13091
13092 static PyObject *Qt_GraphicsExportSetCompressionMethod(PyObject *_self, PyObject *_args)
13093 {
13094     PyObject *_res = NULL;
13095     ComponentResult _rv;
13096     GraphicsExportComponent ci;
13097     long compressionMethod;
13098 #ifndef GraphicsExportSetCompressionMethod
13099     PyMac_PRECHECK(GraphicsExportSetCompressionMethod);
13100 #endif
13101     if (!PyArg_ParseTuple(_args, "O&l",
13102                           CmpInstObj_Convert, &ci,
13103                           &compressionMethod))
13104         return NULL;
13105     _rv = GraphicsExportSetCompressionMethod(ci,
13106                                              compressionMethod);
13107     _res = Py_BuildValue("l",
13108                          _rv);
13109     return _res;
13110 }
13111
13112 static PyObject *Qt_GraphicsExportGetCompressionMethod(PyObject *_self, PyObject *_args)
13113 {
13114     PyObject *_res = NULL;
13115     ComponentResult _rv;
13116     GraphicsExportComponent ci;
13117     long compressionMethod;
13118 #ifndef GraphicsExportGetCompressionMethod
13119     PyMac_PRECHECK(GraphicsExportGetCompressionMethod);
13120 #endif
13121     if (!PyArg_ParseTuple(_args, "O&",
13122                           CmpInstObj_Convert, &ci))
13123         return NULL;
13124     _rv = GraphicsExportGetCompressionMethod(ci,
13125                                              &compressionMethod);
13126     _res = Py_BuildValue("ll",
13127                          _rv,
13128                          compressionMethod);
13129     return _res;
13130 }
13131
13132 static PyObject *Qt_GraphicsExportSetCompressionQuality(PyObject *_self, PyObject *_args)
13133 {
13134     PyObject *_res = NULL;
13135     ComponentResult _rv;
13136     GraphicsExportComponent ci;
13137     CodecQ spatialQuality;
13138 #ifndef GraphicsExportSetCompressionQuality
13139     PyMac_PRECHECK(GraphicsExportSetCompressionQuality);
13140 #endif
13141     if (!PyArg_ParseTuple(_args, "O&l",
13142                           CmpInstObj_Convert, &ci,
13143                           &spatialQuality))
13144         return NULL;
13145     _rv = GraphicsExportSetCompressionQuality(ci,
13146                                               spatialQuality);
13147     _res = Py_BuildValue("l",
13148                          _rv);
13149     return _res;
13150 }
13151
13152 static PyObject *Qt_GraphicsExportGetCompressionQuality(PyObject *_self, PyObject *_args)
13153 {
13154     PyObject *_res = NULL;
13155     ComponentResult _rv;
13156     GraphicsExportComponent ci;
13157     CodecQ spatialQuality;
13158 #ifndef GraphicsExportGetCompressionQuality
13159     PyMac_PRECHECK(GraphicsExportGetCompressionQuality);
13160 #endif
13161     if (!PyArg_ParseTuple(_args, "O&",
13162                           CmpInstObj_Convert, &ci))
13163         return NULL;
13164     _rv = GraphicsExportGetCompressionQuality(ci,
13165                                               &spatialQuality);
13166     _res = Py_BuildValue("ll",
13167                          _rv,
13168                          spatialQuality);
13169     return _res;
13170 }
13171
13172 static PyObject *Qt_GraphicsExportSetResolution(PyObject *_self, PyObject *_args)
13173 {
13174     PyObject *_res = NULL;
13175     ComponentResult _rv;
13176     GraphicsExportComponent ci;
13177     Fixed horizontalResolution;
13178     Fixed verticalResolution;
13179 #ifndef GraphicsExportSetResolution
13180     PyMac_PRECHECK(GraphicsExportSetResolution);
13181 #endif
13182     if (!PyArg_ParseTuple(_args, "O&O&O&",
13183                           CmpInstObj_Convert, &ci,
13184                           PyMac_GetFixed, &horizontalResolution,
13185                           PyMac_GetFixed, &verticalResolution))
13186         return NULL;
13187     _rv = GraphicsExportSetResolution(ci,
13188                                       horizontalResolution,
13189                                       verticalResolution);
13190     _res = Py_BuildValue("l",
13191                          _rv);
13192     return _res;
13193 }
13194
13195 static PyObject *Qt_GraphicsExportGetResolution(PyObject *_self, PyObject *_args)
13196 {
13197     PyObject *_res = NULL;
13198     ComponentResult _rv;
13199     GraphicsExportComponent ci;
13200     Fixed horizontalResolution;
13201     Fixed verticalResolution;
13202 #ifndef GraphicsExportGetResolution
13203     PyMac_PRECHECK(GraphicsExportGetResolution);
13204 #endif
13205     if (!PyArg_ParseTuple(_args, "O&",
13206                           CmpInstObj_Convert, &ci))
13207         return NULL;
13208     _rv = GraphicsExportGetResolution(ci,
13209                                       &horizontalResolution,
13210                                       &verticalResolution);
13211     _res = Py_BuildValue("lO&O&",
13212                          _rv,
13213                          PyMac_BuildFixed, horizontalResolution,
13214                          PyMac_BuildFixed, verticalResolution);
13215     return _res;
13216 }
13217
13218 static PyObject *Qt_GraphicsExportSetDepth(PyObject *_self, PyObject *_args)
13219 {
13220     PyObject *_res = NULL;
13221     ComponentResult _rv;
13222     GraphicsExportComponent ci;
13223     long depth;
13224 #ifndef GraphicsExportSetDepth
13225     PyMac_PRECHECK(GraphicsExportSetDepth);
13226 #endif
13227     if (!PyArg_ParseTuple(_args, "O&l",
13228                           CmpInstObj_Convert, &ci,
13229                           &depth))
13230         return NULL;
13231     _rv = GraphicsExportSetDepth(ci,
13232                                  depth);
13233     _res = Py_BuildValue("l",
13234                          _rv);
13235     return _res;
13236 }
13237
13238 static PyObject *Qt_GraphicsExportGetDepth(PyObject *_self, PyObject *_args)
13239 {
13240     PyObject *_res = NULL;
13241     ComponentResult _rv;
13242     GraphicsExportComponent ci;
13243     long depth;
13244 #ifndef GraphicsExportGetDepth
13245     PyMac_PRECHECK(GraphicsExportGetDepth);
13246 #endif
13247     if (!PyArg_ParseTuple(_args, "O&",
13248                           CmpInstObj_Convert, &ci))
13249         return NULL;
13250     _rv = GraphicsExportGetDepth(ci,
13251                                  &depth);
13252     _res = Py_BuildValue("ll",
13253                          _rv,
13254                          depth);
13255     return _res;
13256 }
13257
13258 static PyObject *Qt_GraphicsExportSetColorSyncProfile(PyObject *_self, PyObject *_args)
13259 {
13260     PyObject *_res = NULL;
13261     ComponentResult _rv;
13262     GraphicsExportComponent ci;
13263     Handle colorSyncProfile;
13264 #ifndef GraphicsExportSetColorSyncProfile
13265     PyMac_PRECHECK(GraphicsExportSetColorSyncProfile);
13266 #endif
13267     if (!PyArg_ParseTuple(_args, "O&O&",
13268                           CmpInstObj_Convert, &ci,
13269                           ResObj_Convert, &colorSyncProfile))
13270         return NULL;
13271     _rv = GraphicsExportSetColorSyncProfile(ci,
13272                                             colorSyncProfile);
13273     _res = Py_BuildValue("l",
13274                          _rv);
13275     return _res;
13276 }
13277
13278 static PyObject *Qt_GraphicsExportGetColorSyncProfile(PyObject *_self, PyObject *_args)
13279 {
13280     PyObject *_res = NULL;
13281     ComponentResult _rv;
13282     GraphicsExportComponent ci;
13283     Handle colorSyncProfile;
13284 #ifndef GraphicsExportGetColorSyncProfile
13285     PyMac_PRECHECK(GraphicsExportGetColorSyncProfile);
13286 #endif
13287     if (!PyArg_ParseTuple(_args, "O&",
13288                           CmpInstObj_Convert, &ci))
13289         return NULL;
13290     _rv = GraphicsExportGetColorSyncProfile(ci,
13291                                             &colorSyncProfile);
13292     _res = Py_BuildValue("lO&",
13293                          _rv,
13294                          ResObj_New, colorSyncProfile);
13295     return _res;
13296 }
13297
13298 static PyObject *Qt_GraphicsExportSetInputDataReference(PyObject *_self, PyObject *_args)
13299 {
13300     PyObject *_res = NULL;
13301     ComponentResult _rv;
13302     GraphicsExportComponent ci;
13303     Handle dataRef;
13304     OSType dataRefType;
13305     ImageDescriptionHandle desc;
13306 #ifndef GraphicsExportSetInputDataReference
13307     PyMac_PRECHECK(GraphicsExportSetInputDataReference);
13308 #endif
13309     if (!PyArg_ParseTuple(_args, "O&O&O&O&",
13310                           CmpInstObj_Convert, &ci,
13311                           ResObj_Convert, &dataRef,
13312                           PyMac_GetOSType, &dataRefType,
13313                           ResObj_Convert, &desc))
13314         return NULL;
13315     _rv = GraphicsExportSetInputDataReference(ci,
13316                                               dataRef,
13317                                               dataRefType,
13318                                               desc);
13319     _res = Py_BuildValue("l",
13320                          _rv);
13321     return _res;
13322 }
13323
13324 static PyObject *Qt_GraphicsExportGetInputDataReference(PyObject *_self, PyObject *_args)
13325 {
13326     PyObject *_res = NULL;
13327     ComponentResult _rv;
13328     GraphicsExportComponent ci;
13329     Handle dataRef;
13330     OSType dataRefType;
13331 #ifndef GraphicsExportGetInputDataReference
13332     PyMac_PRECHECK(GraphicsExportGetInputDataReference);
13333 #endif
13334     if (!PyArg_ParseTuple(_args, "O&",
13335                           CmpInstObj_Convert, &ci))
13336         return NULL;
13337     _rv = GraphicsExportGetInputDataReference(ci,
13338                                               &dataRef,
13339                                               &dataRefType);
13340     _res = Py_BuildValue("lO&O&",
13341                          _rv,
13342                          ResObj_New, dataRef,
13343                          PyMac_BuildOSType, dataRefType);
13344     return _res;
13345 }
13346
13347 static PyObject *Qt_GraphicsExportSetInputFile(PyObject *_self, PyObject *_args)
13348 {
13349     PyObject *_res = NULL;
13350     ComponentResult _rv;
13351     GraphicsExportComponent ci;
13352     FSSpec theFile;
13353     ImageDescriptionHandle desc;
13354 #ifndef GraphicsExportSetInputFile
13355     PyMac_PRECHECK(GraphicsExportSetInputFile);
13356 #endif
13357     if (!PyArg_ParseTuple(_args, "O&O&O&",
13358                           CmpInstObj_Convert, &ci,
13359                           PyMac_GetFSSpec, &theFile,
13360                           ResObj_Convert, &desc))
13361         return NULL;
13362     _rv = GraphicsExportSetInputFile(ci,
13363                                      &theFile,
13364                                      desc);
13365     _res = Py_BuildValue("l",
13366                          _rv);
13367     return _res;
13368 }
13369
13370 static PyObject *Qt_GraphicsExportGetInputFile(PyObject *_self, PyObject *_args)
13371 {
13372     PyObject *_res = NULL;
13373     ComponentResult _rv;
13374     GraphicsExportComponent ci;
13375     FSSpec theFile;
13376 #ifndef GraphicsExportGetInputFile
13377     PyMac_PRECHECK(GraphicsExportGetInputFile);
13378 #endif
13379     if (!PyArg_ParseTuple(_args, "O&O&",
13380                           CmpInstObj_Convert, &ci,
13381                           PyMac_GetFSSpec, &theFile))
13382         return NULL;
13383     _rv = GraphicsExportGetInputFile(ci,
13384                                      &theFile);
13385     _res = Py_BuildValue("l",
13386                          _rv);
13387     return _res;
13388 }
13389
13390 static PyObject *Qt_GraphicsExportSetInputHandle(PyObject *_self, PyObject *_args)
13391 {
13392     PyObject *_res = NULL;
13393     ComponentResult _rv;
13394     GraphicsExportComponent ci;
13395     Handle h;
13396     ImageDescriptionHandle desc;
13397 #ifndef GraphicsExportSetInputHandle
13398     PyMac_PRECHECK(GraphicsExportSetInputHandle);
13399 #endif
13400     if (!PyArg_ParseTuple(_args, "O&O&O&",
13401                           CmpInstObj_Convert, &ci,
13402                           ResObj_Convert, &h,
13403                           ResObj_Convert, &desc))
13404         return NULL;
13405     _rv = GraphicsExportSetInputHandle(ci,
13406                                        h,
13407                                        desc);
13408     _res = Py_BuildValue("l",
13409                          _rv);
13410     return _res;
13411 }
13412
13413 static PyObject *Qt_GraphicsExportGetInputHandle(PyObject *_self, PyObject *_args)
13414 {
13415     PyObject *_res = NULL;
13416     ComponentResult _rv;
13417     GraphicsExportComponent ci;
13418     Handle h;
13419 #ifndef GraphicsExportGetInputHandle
13420     PyMac_PRECHECK(GraphicsExportGetInputHandle);
13421 #endif
13422     if (!PyArg_ParseTuple(_args, "O&",
13423                           CmpInstObj_Convert, &ci))
13424         return NULL;
13425     _rv = GraphicsExportGetInputHandle(ci,
13426                                        &h);
13427     _res = Py_BuildValue("lO&",
13428                          _rv,
13429                          ResObj_New, h);
13430     return _res;
13431 }
13432
13433 static PyObject *Qt_GraphicsExportSetInputPtr(PyObject *_self, PyObject *_args)
13434 {
13435     PyObject *_res = NULL;
13436     ComponentResult _rv;
13437     GraphicsExportComponent ci;
13438     Ptr p;
13439     unsigned long size;
13440     ImageDescriptionHandle desc;
13441 #ifndef GraphicsExportSetInputPtr
13442     PyMac_PRECHECK(GraphicsExportSetInputPtr);
13443 #endif
13444     if (!PyArg_ParseTuple(_args, "O&slO&",
13445                           CmpInstObj_Convert, &ci,
13446                           &p,
13447                           &size,
13448                           ResObj_Convert, &desc))
13449         return NULL;
13450     _rv = GraphicsExportSetInputPtr(ci,
13451                                     p,
13452                                     size,
13453                                     desc);
13454     _res = Py_BuildValue("l",
13455                          _rv);
13456     return _res;
13457 }
13458
13459 static PyObject *Qt_GraphicsExportSetInputGraphicsImporter(PyObject *_self, PyObject *_args)
13460 {
13461     PyObject *_res = NULL;
13462     ComponentResult _rv;
13463     GraphicsExportComponent ci;
13464     GraphicsImportComponent grip;
13465 #ifndef GraphicsExportSetInputGraphicsImporter
13466     PyMac_PRECHECK(GraphicsExportSetInputGraphicsImporter);
13467 #endif
13468     if (!PyArg_ParseTuple(_args, "O&O&",
13469                           CmpInstObj_Convert, &ci,
13470                           CmpInstObj_Convert, &grip))
13471         return NULL;
13472     _rv = GraphicsExportSetInputGraphicsImporter(ci,
13473                                                  grip);
13474     _res = Py_BuildValue("l",
13475                          _rv);
13476     return _res;
13477 }
13478
13479 static PyObject *Qt_GraphicsExportGetInputGraphicsImporter(PyObject *_self, PyObject *_args)
13480 {
13481     PyObject *_res = NULL;
13482     ComponentResult _rv;
13483     GraphicsExportComponent ci;
13484     GraphicsImportComponent grip;
13485 #ifndef GraphicsExportGetInputGraphicsImporter
13486     PyMac_PRECHECK(GraphicsExportGetInputGraphicsImporter);
13487 #endif
13488     if (!PyArg_ParseTuple(_args, "O&",
13489                           CmpInstObj_Convert, &ci))
13490         return NULL;
13491     _rv = GraphicsExportGetInputGraphicsImporter(ci,
13492                                                  &grip);
13493     _res = Py_BuildValue("lO&",
13494                          _rv,
13495                          CmpInstObj_New, grip);
13496     return _res;
13497 }
13498
13499 static PyObject *Qt_GraphicsExportSetInputPicture(PyObject *_self, PyObject *_args)
13500 {
13501     PyObject *_res = NULL;
13502     ComponentResult _rv;
13503     GraphicsExportComponent ci;
13504     PicHandle picture;
13505 #ifndef GraphicsExportSetInputPicture
13506     PyMac_PRECHECK(GraphicsExportSetInputPicture);
13507 #endif
13508     if (!PyArg_ParseTuple(_args, "O&O&",
13509                           CmpInstObj_Convert, &ci,
13510                           ResObj_Convert, &picture))
13511         return NULL;
13512     _rv = GraphicsExportSetInputPicture(ci,
13513                                         picture);
13514     _res = Py_BuildValue("l",
13515                          _rv);
13516     return _res;
13517 }
13518
13519 static PyObject *Qt_GraphicsExportGetInputPicture(PyObject *_self, PyObject *_args)
13520 {
13521     PyObject *_res = NULL;
13522     ComponentResult _rv;
13523     GraphicsExportComponent ci;
13524     PicHandle picture;
13525 #ifndef GraphicsExportGetInputPicture
13526     PyMac_PRECHECK(GraphicsExportGetInputPicture);
13527 #endif
13528     if (!PyArg_ParseTuple(_args, "O&",
13529                           CmpInstObj_Convert, &ci))
13530         return NULL;
13531     _rv = GraphicsExportGetInputPicture(ci,
13532                                         &picture);
13533     _res = Py_BuildValue("lO&",
13534                          _rv,
13535                          ResObj_New, picture);
13536     return _res;
13537 }
13538
13539 static PyObject *Qt_GraphicsExportSetInputGWorld(PyObject *_self, PyObject *_args)
13540 {
13541     PyObject *_res = NULL;
13542     ComponentResult _rv;
13543     GraphicsExportComponent ci;
13544     GWorldPtr gworld;
13545 #ifndef GraphicsExportSetInputGWorld
13546     PyMac_PRECHECK(GraphicsExportSetInputGWorld);
13547 #endif
13548     if (!PyArg_ParseTuple(_args, "O&O&",
13549                           CmpInstObj_Convert, &ci,
13550                           GWorldObj_Convert, &gworld))
13551         return NULL;
13552     _rv = GraphicsExportSetInputGWorld(ci,
13553                                        gworld);
13554     _res = Py_BuildValue("l",
13555                          _rv);
13556     return _res;
13557 }
13558
13559 static PyObject *Qt_GraphicsExportGetInputGWorld(PyObject *_self, PyObject *_args)
13560 {
13561     PyObject *_res = NULL;
13562     ComponentResult _rv;
13563     GraphicsExportComponent ci;
13564     GWorldPtr gworld;
13565 #ifndef GraphicsExportGetInputGWorld
13566     PyMac_PRECHECK(GraphicsExportGetInputGWorld);
13567 #endif
13568     if (!PyArg_ParseTuple(_args, "O&",
13569                           CmpInstObj_Convert, &ci))
13570         return NULL;
13571     _rv = GraphicsExportGetInputGWorld(ci,
13572                                        &gworld);
13573     _res = Py_BuildValue("lO&",
13574                          _rv,
13575                          GWorldObj_New, gworld);
13576     return _res;
13577 }
13578
13579 static PyObject *Qt_GraphicsExportSetInputPixmap(PyObject *_self, PyObject *_args)
13580 {
13581     PyObject *_res = NULL;
13582     ComponentResult _rv;
13583     GraphicsExportComponent ci;
13584     PixMapHandle pixmap;
13585 #ifndef GraphicsExportSetInputPixmap
13586     PyMac_PRECHECK(GraphicsExportSetInputPixmap);
13587 #endif
13588     if (!PyArg_ParseTuple(_args, "O&O&",
13589                           CmpInstObj_Convert, &ci,
13590                           ResObj_Convert, &pixmap))
13591         return NULL;
13592     _rv = GraphicsExportSetInputPixmap(ci,
13593                                        pixmap);
13594     _res = Py_BuildValue("l",
13595                          _rv);
13596     return _res;
13597 }
13598
13599 static PyObject *Qt_GraphicsExportGetInputPixmap(PyObject *_self, PyObject *_args)
13600 {
13601     PyObject *_res = NULL;
13602     ComponentResult _rv;
13603     GraphicsExportComponent ci;
13604     PixMapHandle pixmap;
13605 #ifndef GraphicsExportGetInputPixmap
13606     PyMac_PRECHECK(GraphicsExportGetInputPixmap);
13607 #endif
13608     if (!PyArg_ParseTuple(_args, "O&",
13609                           CmpInstObj_Convert, &ci))
13610         return NULL;
13611     _rv = GraphicsExportGetInputPixmap(ci,
13612                                        &pixmap);
13613     _res = Py_BuildValue("lO&",
13614                          _rv,
13615                          ResObj_New, pixmap);
13616     return _res;
13617 }
13618
13619 static PyObject *Qt_GraphicsExportSetInputOffsetAndLimit(PyObject *_self, PyObject *_args)
13620 {
13621     PyObject *_res = NULL;
13622     ComponentResult _rv;
13623     GraphicsExportComponent ci;
13624     unsigned long offset;
13625     unsigned long limit;
13626 #ifndef GraphicsExportSetInputOffsetAndLimit
13627     PyMac_PRECHECK(GraphicsExportSetInputOffsetAndLimit);
13628 #endif
13629     if (!PyArg_ParseTuple(_args, "O&ll",
13630                           CmpInstObj_Convert, &ci,
13631                           &offset,
13632                           &limit))
13633         return NULL;
13634     _rv = GraphicsExportSetInputOffsetAndLimit(ci,
13635                                                offset,
13636                                                limit);
13637     _res = Py_BuildValue("l",
13638                          _rv);
13639     return _res;
13640 }
13641
13642 static PyObject *Qt_GraphicsExportGetInputOffsetAndLimit(PyObject *_self, PyObject *_args)
13643 {
13644     PyObject *_res = NULL;
13645     ComponentResult _rv;
13646     GraphicsExportComponent ci;
13647     unsigned long offset;
13648     unsigned long limit;
13649 #ifndef GraphicsExportGetInputOffsetAndLimit
13650     PyMac_PRECHECK(GraphicsExportGetInputOffsetAndLimit);
13651 #endif
13652     if (!PyArg_ParseTuple(_args, "O&",
13653                           CmpInstObj_Convert, &ci))
13654         return NULL;
13655     _rv = GraphicsExportGetInputOffsetAndLimit(ci,
13656                                                &offset,
13657                                                &limit);
13658     _res = Py_BuildValue("lll",
13659                          _rv,
13660                          offset,
13661                          limit);
13662     return _res;
13663 }
13664
13665 static PyObject *Qt_GraphicsExportMayExporterReadInputData(PyObject *_self, PyObject *_args)
13666 {
13667     PyObject *_res = NULL;
13668     ComponentResult _rv;
13669     GraphicsExportComponent ci;
13670     Boolean mayReadInputData;
13671 #ifndef GraphicsExportMayExporterReadInputData
13672     PyMac_PRECHECK(GraphicsExportMayExporterReadInputData);
13673 #endif
13674     if (!PyArg_ParseTuple(_args, "O&",
13675                           CmpInstObj_Convert, &ci))
13676         return NULL;
13677     _rv = GraphicsExportMayExporterReadInputData(ci,
13678                                                  &mayReadInputData);
13679     _res = Py_BuildValue("lb",
13680                          _rv,
13681                          mayReadInputData);
13682     return _res;
13683 }
13684
13685 static PyObject *Qt_GraphicsExportGetInputDataSize(PyObject *_self, PyObject *_args)
13686 {
13687     PyObject *_res = NULL;
13688     ComponentResult _rv;
13689     GraphicsExportComponent ci;
13690     unsigned long size;
13691 #ifndef GraphicsExportGetInputDataSize
13692     PyMac_PRECHECK(GraphicsExportGetInputDataSize);
13693 #endif
13694     if (!PyArg_ParseTuple(_args, "O&",
13695                           CmpInstObj_Convert, &ci))
13696         return NULL;
13697     _rv = GraphicsExportGetInputDataSize(ci,
13698                                          &size);
13699     _res = Py_BuildValue("ll",
13700                          _rv,
13701                          size);
13702     return _res;
13703 }
13704
13705 static PyObject *Qt_GraphicsExportReadInputData(PyObject *_self, PyObject *_args)
13706 {
13707     PyObject *_res = NULL;
13708     ComponentResult _rv;
13709     GraphicsExportComponent ci;
13710     void * dataPtr;
13711     unsigned long dataOffset;
13712     unsigned long dataSize;
13713 #ifndef GraphicsExportReadInputData
13714     PyMac_PRECHECK(GraphicsExportReadInputData);
13715 #endif
13716     if (!PyArg_ParseTuple(_args, "O&sll",
13717                           CmpInstObj_Convert, &ci,
13718                           &dataPtr,
13719                           &dataOffset,
13720                           &dataSize))
13721         return NULL;
13722     _rv = GraphicsExportReadInputData(ci,
13723                                       dataPtr,
13724                                       dataOffset,
13725                                       dataSize);
13726     _res = Py_BuildValue("l",
13727                          _rv);
13728     return _res;
13729 }
13730
13731 static PyObject *Qt_GraphicsExportGetInputImageDescription(PyObject *_self, PyObject *_args)
13732 {
13733     PyObject *_res = NULL;
13734     ComponentResult _rv;
13735     GraphicsExportComponent ci;
13736     ImageDescriptionHandle desc;
13737 #ifndef GraphicsExportGetInputImageDescription
13738     PyMac_PRECHECK(GraphicsExportGetInputImageDescription);
13739 #endif
13740     if (!PyArg_ParseTuple(_args, "O&",
13741                           CmpInstObj_Convert, &ci))
13742         return NULL;
13743     _rv = GraphicsExportGetInputImageDescription(ci,
13744                                                  &desc);
13745     _res = Py_BuildValue("lO&",
13746                          _rv,
13747                          ResObj_New, desc);
13748     return _res;
13749 }
13750
13751 static PyObject *Qt_GraphicsExportGetInputImageDimensions(PyObject *_self, PyObject *_args)
13752 {
13753     PyObject *_res = NULL;
13754     ComponentResult _rv;
13755     GraphicsExportComponent ci;
13756     Rect dimensions;
13757 #ifndef GraphicsExportGetInputImageDimensions
13758     PyMac_PRECHECK(GraphicsExportGetInputImageDimensions);
13759 #endif
13760     if (!PyArg_ParseTuple(_args, "O&",
13761                           CmpInstObj_Convert, &ci))
13762         return NULL;
13763     _rv = GraphicsExportGetInputImageDimensions(ci,
13764                                                 &dimensions);
13765     _res = Py_BuildValue("lO&",
13766                          _rv,
13767                          PyMac_BuildRect, &dimensions);
13768     return _res;
13769 }
13770
13771 static PyObject *Qt_GraphicsExportGetInputImageDepth(PyObject *_self, PyObject *_args)
13772 {
13773     PyObject *_res = NULL;
13774     ComponentResult _rv;
13775     GraphicsExportComponent ci;
13776     long inputDepth;
13777 #ifndef GraphicsExportGetInputImageDepth
13778     PyMac_PRECHECK(GraphicsExportGetInputImageDepth);
13779 #endif
13780     if (!PyArg_ParseTuple(_args, "O&",
13781                           CmpInstObj_Convert, &ci))
13782         return NULL;
13783     _rv = GraphicsExportGetInputImageDepth(ci,
13784                                            &inputDepth);
13785     _res = Py_BuildValue("ll",
13786                          _rv,
13787                          inputDepth);
13788     return _res;
13789 }
13790
13791 static PyObject *Qt_GraphicsExportDrawInputImage(PyObject *_self, PyObject *_args)
13792 {
13793     PyObject *_res = NULL;
13794     ComponentResult _rv;
13795     GraphicsExportComponent ci;
13796     CGrafPtr gw;
13797     GDHandle gd;
13798     Rect srcRect;
13799     Rect dstRect;
13800 #ifndef GraphicsExportDrawInputImage
13801     PyMac_PRECHECK(GraphicsExportDrawInputImage);
13802 #endif
13803     if (!PyArg_ParseTuple(_args, "O&O&O&O&O&",
13804                           CmpInstObj_Convert, &ci,
13805                           GrafObj_Convert, &gw,
13806                           OptResObj_Convert, &gd,
13807                           PyMac_GetRect, &srcRect,
13808                           PyMac_GetRect, &dstRect))
13809         return NULL;
13810     _rv = GraphicsExportDrawInputImage(ci,
13811                                        gw,
13812                                        gd,
13813                                        &srcRect,
13814                                        &dstRect);
13815     _res = Py_BuildValue("l",
13816                          _rv);
13817     return _res;
13818 }
13819
13820 static PyObject *Qt_GraphicsExportSetOutputDataReference(PyObject *_self, PyObject *_args)
13821 {
13822     PyObject *_res = NULL;
13823     ComponentResult _rv;
13824     GraphicsExportComponent ci;
13825     Handle dataRef;
13826     OSType dataRefType;
13827 #ifndef GraphicsExportSetOutputDataReference
13828     PyMac_PRECHECK(GraphicsExportSetOutputDataReference);
13829 #endif
13830     if (!PyArg_ParseTuple(_args, "O&O&O&",
13831                           CmpInstObj_Convert, &ci,
13832                           ResObj_Convert, &dataRef,
13833                           PyMac_GetOSType, &dataRefType))
13834         return NULL;
13835     _rv = GraphicsExportSetOutputDataReference(ci,
13836                                                dataRef,
13837                                                dataRefType);
13838     _res = Py_BuildValue("l",
13839                          _rv);
13840     return _res;
13841 }
13842
13843 static PyObject *Qt_GraphicsExportGetOutputDataReference(PyObject *_self, PyObject *_args)
13844 {
13845     PyObject *_res = NULL;
13846     ComponentResult _rv;
13847     GraphicsExportComponent ci;
13848     Handle dataRef;
13849     OSType dataRefType;
13850 #ifndef GraphicsExportGetOutputDataReference
13851     PyMac_PRECHECK(GraphicsExportGetOutputDataReference);
13852 #endif
13853     if (!PyArg_ParseTuple(_args, "O&",
13854                           CmpInstObj_Convert, &ci))
13855         return NULL;
13856     _rv = GraphicsExportGetOutputDataReference(ci,
13857                                                &dataRef,
13858                                                &dataRefType);
13859     _res = Py_BuildValue("lO&O&",
13860                          _rv,
13861                          ResObj_New, dataRef,
13862                          PyMac_BuildOSType, dataRefType);
13863     return _res;
13864 }
13865
13866 static PyObject *Qt_GraphicsExportSetOutputFile(PyObject *_self, PyObject *_args)
13867 {
13868     PyObject *_res = NULL;
13869     ComponentResult _rv;
13870     GraphicsExportComponent ci;
13871     FSSpec theFile;
13872 #ifndef GraphicsExportSetOutputFile
13873     PyMac_PRECHECK(GraphicsExportSetOutputFile);
13874 #endif
13875     if (!PyArg_ParseTuple(_args, "O&O&",
13876                           CmpInstObj_Convert, &ci,
13877                           PyMac_GetFSSpec, &theFile))
13878         return NULL;
13879     _rv = GraphicsExportSetOutputFile(ci,
13880                                       &theFile);
13881     _res = Py_BuildValue("l",
13882                          _rv);
13883     return _res;
13884 }
13885
13886 static PyObject *Qt_GraphicsExportGetOutputFile(PyObject *_self, PyObject *_args)
13887 {
13888     PyObject *_res = NULL;
13889     ComponentResult _rv;
13890     GraphicsExportComponent ci;
13891     FSSpec theFile;
13892 #ifndef GraphicsExportGetOutputFile
13893     PyMac_PRECHECK(GraphicsExportGetOutputFile);
13894 #endif
13895     if (!PyArg_ParseTuple(_args, "O&O&",
13896                           CmpInstObj_Convert, &ci,
13897                           PyMac_GetFSSpec, &theFile))
13898         return NULL;
13899     _rv = GraphicsExportGetOutputFile(ci,
13900                                       &theFile);
13901     _res = Py_BuildValue("l",
13902                          _rv);
13903     return _res;
13904 }
13905
13906 static PyObject *Qt_GraphicsExportSetOutputHandle(PyObject *_self, PyObject *_args)
13907 {
13908     PyObject *_res = NULL;
13909     ComponentResult _rv;
13910     GraphicsExportComponent ci;
13911     Handle h;
13912 #ifndef GraphicsExportSetOutputHandle
13913     PyMac_PRECHECK(GraphicsExportSetOutputHandle);
13914 #endif
13915     if (!PyArg_ParseTuple(_args, "O&O&",
13916                           CmpInstObj_Convert, &ci,
13917                           ResObj_Convert, &h))
13918         return NULL;
13919     _rv = GraphicsExportSetOutputHandle(ci,
13920                                         h);
13921     _res = Py_BuildValue("l",
13922                          _rv);
13923     return _res;
13924 }
13925
13926 static PyObject *Qt_GraphicsExportGetOutputHandle(PyObject *_self, PyObject *_args)
13927 {
13928     PyObject *_res = NULL;
13929     ComponentResult _rv;
13930     GraphicsExportComponent ci;
13931     Handle h;
13932 #ifndef GraphicsExportGetOutputHandle
13933     PyMac_PRECHECK(GraphicsExportGetOutputHandle);
13934 #endif
13935     if (!PyArg_ParseTuple(_args, "O&",
13936                           CmpInstObj_Convert, &ci))
13937         return NULL;
13938     _rv = GraphicsExportGetOutputHandle(ci,
13939                                         &h);
13940     _res = Py_BuildValue("lO&",
13941                          _rv,
13942                          ResObj_New, h);
13943     return _res;
13944 }
13945
13946 static PyObject *Qt_GraphicsExportSetOutputOffsetAndMaxSize(PyObject *_self, PyObject *_args)
13947 {
13948     PyObject *_res = NULL;
13949     ComponentResult _rv;
13950     GraphicsExportComponent ci;
13951     unsigned long offset;
13952     unsigned long maxSize;
13953     Boolean truncateFile;
13954 #ifndef GraphicsExportSetOutputOffsetAndMaxSize
13955     PyMac_PRECHECK(GraphicsExportSetOutputOffsetAndMaxSize);
13956 #endif
13957     if (!PyArg_ParseTuple(_args, "O&llb",
13958                           CmpInstObj_Convert, &ci,
13959                           &offset,
13960                           &maxSize,
13961                           &truncateFile))
13962         return NULL;
13963     _rv = GraphicsExportSetOutputOffsetAndMaxSize(ci,
13964                                                   offset,
13965                                                   maxSize,
13966                                                   truncateFile);
13967     _res = Py_BuildValue("l",
13968                          _rv);
13969     return _res;
13970 }
13971
13972 static PyObject *Qt_GraphicsExportGetOutputOffsetAndMaxSize(PyObject *_self, PyObject *_args)
13973 {
13974     PyObject *_res = NULL;
13975     ComponentResult _rv;
13976     GraphicsExportComponent ci;
13977     unsigned long offset;
13978     unsigned long maxSize;
13979     Boolean truncateFile;
13980 #ifndef GraphicsExportGetOutputOffsetAndMaxSize
13981     PyMac_PRECHECK(GraphicsExportGetOutputOffsetAndMaxSize);
13982 #endif
13983     if (!PyArg_ParseTuple(_args, "O&",
13984                           CmpInstObj_Convert, &ci))
13985         return NULL;
13986     _rv = GraphicsExportGetOutputOffsetAndMaxSize(ci,
13987                                                   &offset,
13988                                                   &maxSize,
13989                                                   &truncateFile);
13990     _res = Py_BuildValue("lllb",
13991                          _rv,
13992                          offset,
13993                          maxSize,
13994                          truncateFile);
13995     return _res;
13996 }
13997
13998 static PyObject *Qt_GraphicsExportSetOutputFileTypeAndCreator(PyObject *_self, PyObject *_args)
13999 {
14000     PyObject *_res = NULL;
14001     ComponentResult _rv;
14002     GraphicsExportComponent ci;
14003     OSType fileType;
14004     OSType fileCreator;
14005 #ifndef GraphicsExportSetOutputFileTypeAndCreator
14006     PyMac_PRECHECK(GraphicsExportSetOutputFileTypeAndCreator);
14007 #endif
14008     if (!PyArg_ParseTuple(_args, "O&O&O&",
14009                           CmpInstObj_Convert, &ci,
14010                           PyMac_GetOSType, &fileType,
14011                           PyMac_GetOSType, &fileCreator))
14012         return NULL;
14013     _rv = GraphicsExportSetOutputFileTypeAndCreator(ci,
14014                                                     fileType,
14015                                                     fileCreator);
14016     _res = Py_BuildValue("l",
14017                          _rv);
14018     return _res;
14019 }
14020
14021 static PyObject *Qt_GraphicsExportGetOutputFileTypeAndCreator(PyObject *_self, PyObject *_args)
14022 {
14023     PyObject *_res = NULL;
14024     ComponentResult _rv;
14025     GraphicsExportComponent ci;
14026     OSType fileType;
14027     OSType fileCreator;
14028 #ifndef GraphicsExportGetOutputFileTypeAndCreator
14029     PyMac_PRECHECK(GraphicsExportGetOutputFileTypeAndCreator);
14030 #endif
14031     if (!PyArg_ParseTuple(_args, "O&",
14032                           CmpInstObj_Convert, &ci))
14033         return NULL;
14034     _rv = GraphicsExportGetOutputFileTypeAndCreator(ci,
14035                                                     &fileType,
14036                                                     &fileCreator);
14037     _res = Py_BuildValue("lO&O&",
14038                          _rv,
14039                          PyMac_BuildOSType, fileType,
14040                          PyMac_BuildOSType, fileCreator);
14041     return _res;
14042 }
14043
14044 static PyObject *Qt_GraphicsExportSetOutputMark(PyObject *_self, PyObject *_args)
14045 {
14046     PyObject *_res = NULL;
14047     ComponentResult _rv;
14048     GraphicsExportComponent ci;
14049     unsigned long mark;
14050 #ifndef GraphicsExportSetOutputMark
14051     PyMac_PRECHECK(GraphicsExportSetOutputMark);
14052 #endif
14053     if (!PyArg_ParseTuple(_args, "O&l",
14054                           CmpInstObj_Convert, &ci,
14055                           &mark))
14056         return NULL;
14057     _rv = GraphicsExportSetOutputMark(ci,
14058                                       mark);
14059     _res = Py_BuildValue("l",
14060                          _rv);
14061     return _res;
14062 }
14063
14064 static PyObject *Qt_GraphicsExportGetOutputMark(PyObject *_self, PyObject *_args)
14065 {
14066     PyObject *_res = NULL;
14067     ComponentResult _rv;
14068     GraphicsExportComponent ci;
14069     unsigned long mark;
14070 #ifndef GraphicsExportGetOutputMark
14071     PyMac_PRECHECK(GraphicsExportGetOutputMark);
14072 #endif
14073     if (!PyArg_ParseTuple(_args, "O&",
14074                           CmpInstObj_Convert, &ci))
14075         return NULL;
14076     _rv = GraphicsExportGetOutputMark(ci,
14077                                       &mark);
14078     _res = Py_BuildValue("ll",
14079                          _rv,
14080                          mark);
14081     return _res;
14082 }
14083
14084 static PyObject *Qt_GraphicsExportReadOutputData(PyObject *_self, PyObject *_args)
14085 {
14086     PyObject *_res = NULL;
14087     ComponentResult _rv;
14088     GraphicsExportComponent ci;
14089     void * dataPtr;
14090     unsigned long dataOffset;
14091     unsigned long dataSize;
14092 #ifndef GraphicsExportReadOutputData
14093     PyMac_PRECHECK(GraphicsExportReadOutputData);
14094 #endif
14095     if (!PyArg_ParseTuple(_args, "O&sll",
14096                           CmpInstObj_Convert, &ci,
14097                           &dataPtr,
14098                           &dataOffset,
14099                           &dataSize))
14100         return NULL;
14101     _rv = GraphicsExportReadOutputData(ci,
14102                                        dataPtr,
14103                                        dataOffset,
14104                                        dataSize);
14105     _res = Py_BuildValue("l",
14106                          _rv);
14107     return _res;
14108 }
14109
14110 static PyObject *Qt_GraphicsExportSetThumbnailEnabled(PyObject *_self, PyObject *_args)
14111 {
14112     PyObject *_res = NULL;
14113     ComponentResult _rv;
14114     GraphicsExportComponent ci;
14115     Boolean enableThumbnail;
14116     long maxThumbnailWidth;
14117     long maxThumbnailHeight;
14118 #ifndef GraphicsExportSetThumbnailEnabled
14119     PyMac_PRECHECK(GraphicsExportSetThumbnailEnabled);
14120 #endif
14121     if (!PyArg_ParseTuple(_args, "O&bll",
14122                           CmpInstObj_Convert, &ci,
14123                           &enableThumbnail,
14124                           &maxThumbnailWidth,
14125                           &maxThumbnailHeight))
14126         return NULL;
14127     _rv = GraphicsExportSetThumbnailEnabled(ci,
14128                                             enableThumbnail,
14129                                             maxThumbnailWidth,
14130                                             maxThumbnailHeight);
14131     _res = Py_BuildValue("l",
14132                          _rv);
14133     return _res;
14134 }
14135
14136 static PyObject *Qt_GraphicsExportGetThumbnailEnabled(PyObject *_self, PyObject *_args)
14137 {
14138     PyObject *_res = NULL;
14139     ComponentResult _rv;
14140     GraphicsExportComponent ci;
14141     Boolean thumbnailEnabled;
14142     long maxThumbnailWidth;
14143     long maxThumbnailHeight;
14144 #ifndef GraphicsExportGetThumbnailEnabled
14145     PyMac_PRECHECK(GraphicsExportGetThumbnailEnabled);
14146 #endif
14147     if (!PyArg_ParseTuple(_args, "O&",
14148                           CmpInstObj_Convert, &ci))
14149         return NULL;
14150     _rv = GraphicsExportGetThumbnailEnabled(ci,
14151                                             &thumbnailEnabled,
14152                                             &maxThumbnailWidth,
14153                                             &maxThumbnailHeight);
14154     _res = Py_BuildValue("lbll",
14155                          _rv,
14156                          thumbnailEnabled,
14157                          maxThumbnailWidth,
14158                          maxThumbnailHeight);
14159     return _res;
14160 }
14161
14162 static PyObject *Qt_GraphicsExportSetExifEnabled(PyObject *_self, PyObject *_args)
14163 {
14164     PyObject *_res = NULL;
14165     ComponentResult _rv;
14166     GraphicsExportComponent ci;
14167     Boolean enableExif;
14168 #ifndef GraphicsExportSetExifEnabled
14169     PyMac_PRECHECK(GraphicsExportSetExifEnabled);
14170 #endif
14171     if (!PyArg_ParseTuple(_args, "O&b",
14172                           CmpInstObj_Convert, &ci,
14173                           &enableExif))
14174         return NULL;
14175     _rv = GraphicsExportSetExifEnabled(ci,
14176                                        enableExif);
14177     _res = Py_BuildValue("l",
14178                          _rv);
14179     return _res;
14180 }
14181
14182 static PyObject *Qt_GraphicsExportGetExifEnabled(PyObject *_self, PyObject *_args)
14183 {
14184     PyObject *_res = NULL;
14185     ComponentResult _rv;
14186     GraphicsExportComponent ci;
14187     Boolean exifEnabled;
14188 #ifndef GraphicsExportGetExifEnabled
14189     PyMac_PRECHECK(GraphicsExportGetExifEnabled);
14190 #endif
14191     if (!PyArg_ParseTuple(_args, "O&",
14192                           CmpInstObj_Convert, &ci))
14193         return NULL;
14194     _rv = GraphicsExportGetExifEnabled(ci,
14195                                        &exifEnabled);
14196     _res = Py_BuildValue("lb",
14197                          _rv,
14198                          exifEnabled);
14199     return _res;
14200 }
14201
14202 static PyObject *Qt_ImageTranscoderBeginSequence(PyObject *_self, PyObject *_args)
14203 {
14204     PyObject *_res = NULL;
14205     ComponentResult _rv;
14206     ImageTranscoderComponent itc;
14207     ImageDescriptionHandle srcDesc;
14208     ImageDescriptionHandle dstDesc;
14209     void * data;
14210     long dataSize;
14211 #ifndef ImageTranscoderBeginSequence
14212     PyMac_PRECHECK(ImageTranscoderBeginSequence);
14213 #endif
14214     if (!PyArg_ParseTuple(_args, "O&O&sl",
14215                           CmpInstObj_Convert, &itc,
14216                           ResObj_Convert, &srcDesc,
14217                           &data,
14218                           &dataSize))
14219         return NULL;
14220     _rv = ImageTranscoderBeginSequence(itc,
14221                                        srcDesc,
14222                                        &dstDesc,
14223                                        data,
14224                                        dataSize);
14225     _res = Py_BuildValue("lO&",
14226                          _rv,
14227                          ResObj_New, dstDesc);
14228     return _res;
14229 }
14230
14231 static PyObject *Qt_ImageTranscoderDisposeData(PyObject *_self, PyObject *_args)
14232 {
14233     PyObject *_res = NULL;
14234     ComponentResult _rv;
14235     ImageTranscoderComponent itc;
14236     void * dstData;
14237 #ifndef ImageTranscoderDisposeData
14238     PyMac_PRECHECK(ImageTranscoderDisposeData);
14239 #endif
14240     if (!PyArg_ParseTuple(_args, "O&s",
14241                           CmpInstObj_Convert, &itc,
14242                           &dstData))
14243         return NULL;
14244     _rv = ImageTranscoderDisposeData(itc,
14245                                      dstData);
14246     _res = Py_BuildValue("l",
14247                          _rv);
14248     return _res;
14249 }
14250
14251 static PyObject *Qt_ImageTranscoderEndSequence(PyObject *_self, PyObject *_args)
14252 {
14253     PyObject *_res = NULL;
14254     ComponentResult _rv;
14255     ImageTranscoderComponent itc;
14256 #ifndef ImageTranscoderEndSequence
14257     PyMac_PRECHECK(ImageTranscoderEndSequence);
14258 #endif
14259     if (!PyArg_ParseTuple(_args, "O&",
14260                           CmpInstObj_Convert, &itc))
14261         return NULL;
14262     _rv = ImageTranscoderEndSequence(itc);
14263     _res = Py_BuildValue("l",
14264                          _rv);
14265     return _res;
14266 }
14267
14268 static PyObject *Qt_ClockGetTime(PyObject *_self, PyObject *_args)
14269 {
14270     PyObject *_res = NULL;
14271     ComponentResult _rv;
14272     ComponentInstance aClock;
14273     TimeRecord out;
14274 #ifndef ClockGetTime
14275     PyMac_PRECHECK(ClockGetTime);
14276 #endif
14277     if (!PyArg_ParseTuple(_args, "O&",
14278                           CmpInstObj_Convert, &aClock))
14279         return NULL;
14280     _rv = ClockGetTime(aClock,
14281                        &out);
14282     _res = Py_BuildValue("lO&",
14283                          _rv,
14284                          QtTimeRecord_New, &out);
14285     return _res;
14286 }
14287
14288 static PyObject *Qt_ClockSetTimeBase(PyObject *_self, PyObject *_args)
14289 {
14290     PyObject *_res = NULL;
14291     ComponentResult _rv;
14292     ComponentInstance aClock;
14293     TimeBase tb;
14294 #ifndef ClockSetTimeBase
14295     PyMac_PRECHECK(ClockSetTimeBase);
14296 #endif
14297     if (!PyArg_ParseTuple(_args, "O&O&",
14298                           CmpInstObj_Convert, &aClock,
14299                           TimeBaseObj_Convert, &tb))
14300         return NULL;
14301     _rv = ClockSetTimeBase(aClock,
14302                            tb);
14303     _res = Py_BuildValue("l",
14304                          _rv);
14305     return _res;
14306 }
14307
14308 static PyObject *Qt_ClockGetRate(PyObject *_self, PyObject *_args)
14309 {
14310     PyObject *_res = NULL;
14311     ComponentResult _rv;
14312     ComponentInstance aClock;
14313     Fixed rate;
14314 #ifndef ClockGetRate
14315     PyMac_PRECHECK(ClockGetRate);
14316 #endif
14317     if (!PyArg_ParseTuple(_args, "O&",
14318                           CmpInstObj_Convert, &aClock))
14319         return NULL;
14320     _rv = ClockGetRate(aClock,
14321                        &rate);
14322     _res = Py_BuildValue("lO&",
14323                          _rv,
14324                          PyMac_BuildFixed, rate);
14325     return _res;
14326 }
14327
14328 static PyObject *Qt_SCPositionRect(PyObject *_self, PyObject *_args)
14329 {
14330     PyObject *_res = NULL;
14331     ComponentResult _rv;
14332     ComponentInstance ci;
14333     Rect rp;
14334     Point where;
14335 #ifndef SCPositionRect
14336     PyMac_PRECHECK(SCPositionRect);
14337 #endif
14338     if (!PyArg_ParseTuple(_args, "O&",
14339                           CmpInstObj_Convert, &ci))
14340         return NULL;
14341     _rv = SCPositionRect(ci,
14342                          &rp,
14343                          &where);
14344     _res = Py_BuildValue("lO&O&",
14345                          _rv,
14346                          PyMac_BuildRect, &rp,
14347                          PyMac_BuildPoint, where);
14348     return _res;
14349 }
14350
14351 static PyObject *Qt_SCPositionDialog(PyObject *_self, PyObject *_args)
14352 {
14353     PyObject *_res = NULL;
14354     ComponentResult _rv;
14355     ComponentInstance ci;
14356     short id;
14357     Point where;
14358 #ifndef SCPositionDialog
14359     PyMac_PRECHECK(SCPositionDialog);
14360 #endif
14361     if (!PyArg_ParseTuple(_args, "O&h",
14362                           CmpInstObj_Convert, &ci,
14363                           &id))
14364         return NULL;
14365     _rv = SCPositionDialog(ci,
14366                            id,
14367                            &where);
14368     _res = Py_BuildValue("lO&",
14369                          _rv,
14370                          PyMac_BuildPoint, where);
14371     return _res;
14372 }
14373
14374 static PyObject *Qt_SCSetTestImagePictHandle(PyObject *_self, PyObject *_args)
14375 {
14376     PyObject *_res = NULL;
14377     ComponentResult _rv;
14378     ComponentInstance ci;
14379     PicHandle testPict;
14380     Rect testRect;
14381     short testFlags;
14382 #ifndef SCSetTestImagePictHandle
14383     PyMac_PRECHECK(SCSetTestImagePictHandle);
14384 #endif
14385     if (!PyArg_ParseTuple(_args, "O&O&h",
14386                           CmpInstObj_Convert, &ci,
14387                           ResObj_Convert, &testPict,
14388                           &testFlags))
14389         return NULL;
14390     _rv = SCSetTestImagePictHandle(ci,
14391                                    testPict,
14392                                    &testRect,
14393                                    testFlags);
14394     _res = Py_BuildValue("lO&",
14395                          _rv,
14396                          PyMac_BuildRect, &testRect);
14397     return _res;
14398 }
14399
14400 static PyObject *Qt_SCSetTestImagePictFile(PyObject *_self, PyObject *_args)
14401 {
14402     PyObject *_res = NULL;
14403     ComponentResult _rv;
14404     ComponentInstance ci;
14405     short testFileRef;
14406     Rect testRect;
14407     short testFlags;
14408 #ifndef SCSetTestImagePictFile
14409     PyMac_PRECHECK(SCSetTestImagePictFile);
14410 #endif
14411     if (!PyArg_ParseTuple(_args, "O&hh",
14412                           CmpInstObj_Convert, &ci,
14413                           &testFileRef,
14414                           &testFlags))
14415         return NULL;
14416     _rv = SCSetTestImagePictFile(ci,
14417                                  testFileRef,
14418                                  &testRect,
14419                                  testFlags);
14420     _res = Py_BuildValue("lO&",
14421                          _rv,
14422                          PyMac_BuildRect, &testRect);
14423     return _res;
14424 }
14425
14426 static PyObject *Qt_SCSetTestImagePixMap(PyObject *_self, PyObject *_args)
14427 {
14428     PyObject *_res = NULL;
14429     ComponentResult _rv;
14430     ComponentInstance ci;
14431     PixMapHandle testPixMap;
14432     Rect testRect;
14433     short testFlags;
14434 #ifndef SCSetTestImagePixMap
14435     PyMac_PRECHECK(SCSetTestImagePixMap);
14436 #endif
14437     if (!PyArg_ParseTuple(_args, "O&O&h",
14438                           CmpInstObj_Convert, &ci,
14439                           ResObj_Convert, &testPixMap,
14440                           &testFlags))
14441         return NULL;
14442     _rv = SCSetTestImagePixMap(ci,
14443                                testPixMap,
14444                                &testRect,
14445                                testFlags);
14446     _res = Py_BuildValue("lO&",
14447                          _rv,
14448                          PyMac_BuildRect, &testRect);
14449     return _res;
14450 }
14451
14452 static PyObject *Qt_SCGetBestDeviceRect(PyObject *_self, PyObject *_args)
14453 {
14454     PyObject *_res = NULL;
14455     ComponentResult _rv;
14456     ComponentInstance ci;
14457     Rect r;
14458 #ifndef SCGetBestDeviceRect
14459     PyMac_PRECHECK(SCGetBestDeviceRect);
14460 #endif
14461     if (!PyArg_ParseTuple(_args, "O&",
14462                           CmpInstObj_Convert, &ci))
14463         return NULL;
14464     _rv = SCGetBestDeviceRect(ci,
14465                               &r);
14466     _res = Py_BuildValue("lO&",
14467                          _rv,
14468                          PyMac_BuildRect, &r);
14469     return _res;
14470 }
14471
14472 static PyObject *Qt_SCRequestImageSettings(PyObject *_self, PyObject *_args)
14473 {
14474     PyObject *_res = NULL;
14475     ComponentResult _rv;
14476     ComponentInstance ci;
14477 #ifndef SCRequestImageSettings
14478     PyMac_PRECHECK(SCRequestImageSettings);
14479 #endif
14480     if (!PyArg_ParseTuple(_args, "O&",
14481                           CmpInstObj_Convert, &ci))
14482         return NULL;
14483     _rv = SCRequestImageSettings(ci);
14484     _res = Py_BuildValue("l",
14485                          _rv);
14486     return _res;
14487 }
14488
14489 static PyObject *Qt_SCCompressImage(PyObject *_self, PyObject *_args)
14490 {
14491     PyObject *_res = NULL;
14492     ComponentResult _rv;
14493     ComponentInstance ci;
14494     PixMapHandle src;
14495     Rect srcRect;
14496     ImageDescriptionHandle desc;
14497     Handle data;
14498 #ifndef SCCompressImage
14499     PyMac_PRECHECK(SCCompressImage);
14500 #endif
14501     if (!PyArg_ParseTuple(_args, "O&O&O&",
14502                           CmpInstObj_Convert, &ci,
14503                           ResObj_Convert, &src,
14504                           PyMac_GetRect, &srcRect))
14505         return NULL;
14506     _rv = SCCompressImage(ci,
14507                           src,
14508                           &srcRect,
14509                           &desc,
14510                           &data);
14511     _res = Py_BuildValue("lO&O&",
14512                          _rv,
14513                          ResObj_New, desc,
14514                          ResObj_New, data);
14515     return _res;
14516 }
14517
14518 static PyObject *Qt_SCCompressPicture(PyObject *_self, PyObject *_args)
14519 {
14520     PyObject *_res = NULL;
14521     ComponentResult _rv;
14522     ComponentInstance ci;
14523     PicHandle srcPicture;
14524     PicHandle dstPicture;
14525 #ifndef SCCompressPicture
14526     PyMac_PRECHECK(SCCompressPicture);
14527 #endif
14528     if (!PyArg_ParseTuple(_args, "O&O&O&",
14529                           CmpInstObj_Convert, &ci,
14530                           ResObj_Convert, &srcPicture,
14531                           ResObj_Convert, &dstPicture))
14532         return NULL;
14533     _rv = SCCompressPicture(ci,
14534                             srcPicture,
14535                             dstPicture);
14536     _res = Py_BuildValue("l",
14537                          _rv);
14538     return _res;
14539 }
14540
14541 static PyObject *Qt_SCCompressPictureFile(PyObject *_self, PyObject *_args)
14542 {
14543     PyObject *_res = NULL;
14544     ComponentResult _rv;
14545     ComponentInstance ci;
14546     short srcRefNum;
14547     short dstRefNum;
14548 #ifndef SCCompressPictureFile
14549     PyMac_PRECHECK(SCCompressPictureFile);
14550 #endif
14551     if (!PyArg_ParseTuple(_args, "O&hh",
14552                           CmpInstObj_Convert, &ci,
14553                           &srcRefNum,
14554                           &dstRefNum))
14555         return NULL;
14556     _rv = SCCompressPictureFile(ci,
14557                                 srcRefNum,
14558                                 dstRefNum);
14559     _res = Py_BuildValue("l",
14560                          _rv);
14561     return _res;
14562 }
14563
14564 static PyObject *Qt_SCRequestSequenceSettings(PyObject *_self, PyObject *_args)
14565 {
14566     PyObject *_res = NULL;
14567     ComponentResult _rv;
14568     ComponentInstance ci;
14569 #ifndef SCRequestSequenceSettings
14570     PyMac_PRECHECK(SCRequestSequenceSettings);
14571 #endif
14572     if (!PyArg_ParseTuple(_args, "O&",
14573                           CmpInstObj_Convert, &ci))
14574         return NULL;
14575     _rv = SCRequestSequenceSettings(ci);
14576     _res = Py_BuildValue("l",
14577                          _rv);
14578     return _res;
14579 }
14580
14581 static PyObject *Qt_SCCompressSequenceBegin(PyObject *_self, PyObject *_args)
14582 {
14583     PyObject *_res = NULL;
14584     ComponentResult _rv;
14585     ComponentInstance ci;
14586     PixMapHandle src;
14587     Rect srcRect;
14588     ImageDescriptionHandle desc;
14589 #ifndef SCCompressSequenceBegin
14590     PyMac_PRECHECK(SCCompressSequenceBegin);
14591 #endif
14592     if (!PyArg_ParseTuple(_args, "O&O&O&",
14593                           CmpInstObj_Convert, &ci,
14594                           ResObj_Convert, &src,
14595                           PyMac_GetRect, &srcRect))
14596         return NULL;
14597     _rv = SCCompressSequenceBegin(ci,
14598                                   src,
14599                                   &srcRect,
14600                                   &desc);
14601     _res = Py_BuildValue("lO&",
14602                          _rv,
14603                          ResObj_New, desc);
14604     return _res;
14605 }
14606
14607 static PyObject *Qt_SCCompressSequenceFrame(PyObject *_self, PyObject *_args)
14608 {
14609     PyObject *_res = NULL;
14610     ComponentResult _rv;
14611     ComponentInstance ci;
14612     PixMapHandle src;
14613     Rect srcRect;
14614     Handle data;
14615     long dataSize;
14616     short notSyncFlag;
14617 #ifndef SCCompressSequenceFrame
14618     PyMac_PRECHECK(SCCompressSequenceFrame);
14619 #endif
14620     if (!PyArg_ParseTuple(_args, "O&O&O&",
14621                           CmpInstObj_Convert, &ci,
14622                           ResObj_Convert, &src,
14623                           PyMac_GetRect, &srcRect))
14624         return NULL;
14625     _rv = SCCompressSequenceFrame(ci,
14626                                   src,
14627                                   &srcRect,
14628                                   &data,
14629                                   &dataSize,
14630                                   &notSyncFlag);
14631     _res = Py_BuildValue("lO&lh",
14632                          _rv,
14633                          ResObj_New, data,
14634                          dataSize,
14635                          notSyncFlag);
14636     return _res;
14637 }
14638
14639 static PyObject *Qt_SCCompressSequenceEnd(PyObject *_self, PyObject *_args)
14640 {
14641     PyObject *_res = NULL;
14642     ComponentResult _rv;
14643     ComponentInstance ci;
14644 #ifndef SCCompressSequenceEnd
14645     PyMac_PRECHECK(SCCompressSequenceEnd);
14646 #endif
14647     if (!PyArg_ParseTuple(_args, "O&",
14648                           CmpInstObj_Convert, &ci))
14649         return NULL;
14650     _rv = SCCompressSequenceEnd(ci);
14651     _res = Py_BuildValue("l",
14652                          _rv);
14653     return _res;
14654 }
14655
14656 static PyObject *Qt_SCDefaultPictHandleSettings(PyObject *_self, PyObject *_args)
14657 {
14658     PyObject *_res = NULL;
14659     ComponentResult _rv;
14660     ComponentInstance ci;
14661     PicHandle srcPicture;
14662     short motion;
14663 #ifndef SCDefaultPictHandleSettings
14664     PyMac_PRECHECK(SCDefaultPictHandleSettings);
14665 #endif
14666     if (!PyArg_ParseTuple(_args, "O&O&h",
14667                           CmpInstObj_Convert, &ci,
14668                           ResObj_Convert, &srcPicture,
14669                           &motion))
14670         return NULL;
14671     _rv = SCDefaultPictHandleSettings(ci,
14672                                       srcPicture,
14673                                       motion);
14674     _res = Py_BuildValue("l",
14675                          _rv);
14676     return _res;
14677 }
14678
14679 static PyObject *Qt_SCDefaultPictFileSettings(PyObject *_self, PyObject *_args)
14680 {
14681     PyObject *_res = NULL;
14682     ComponentResult _rv;
14683     ComponentInstance ci;
14684     short srcRef;
14685     short motion;
14686 #ifndef SCDefaultPictFileSettings
14687     PyMac_PRECHECK(SCDefaultPictFileSettings);
14688 #endif
14689     if (!PyArg_ParseTuple(_args, "O&hh",
14690                           CmpInstObj_Convert, &ci,
14691                           &srcRef,
14692                           &motion))
14693         return NULL;
14694     _rv = SCDefaultPictFileSettings(ci,
14695                                     srcRef,
14696                                     motion);
14697     _res = Py_BuildValue("l",
14698                          _rv);
14699     return _res;
14700 }
14701
14702 static PyObject *Qt_SCDefaultPixMapSettings(PyObject *_self, PyObject *_args)
14703 {
14704     PyObject *_res = NULL;
14705     ComponentResult _rv;
14706     ComponentInstance ci;
14707     PixMapHandle src;
14708     short motion;
14709 #ifndef SCDefaultPixMapSettings
14710     PyMac_PRECHECK(SCDefaultPixMapSettings);
14711 #endif
14712     if (!PyArg_ParseTuple(_args, "O&O&h",
14713                           CmpInstObj_Convert, &ci,
14714                           ResObj_Convert, &src,
14715                           &motion))
14716         return NULL;
14717     _rv = SCDefaultPixMapSettings(ci,
14718                                   src,
14719                                   motion);
14720     _res = Py_BuildValue("l",
14721                          _rv);
14722     return _res;
14723 }
14724
14725 static PyObject *Qt_SCGetInfo(PyObject *_self, PyObject *_args)
14726 {
14727     PyObject *_res = NULL;
14728     ComponentResult _rv;
14729     ComponentInstance ci;
14730     OSType infoType;
14731     void * info;
14732 #ifndef SCGetInfo
14733     PyMac_PRECHECK(SCGetInfo);
14734 #endif
14735     if (!PyArg_ParseTuple(_args, "O&O&s",
14736                           CmpInstObj_Convert, &ci,
14737                           PyMac_GetOSType, &infoType,
14738                           &info))
14739         return NULL;
14740     _rv = SCGetInfo(ci,
14741                     infoType,
14742                     info);
14743     _res = Py_BuildValue("l",
14744                          _rv);
14745     return _res;
14746 }
14747
14748 static PyObject *Qt_SCSetInfo(PyObject *_self, PyObject *_args)
14749 {
14750     PyObject *_res = NULL;
14751     ComponentResult _rv;
14752     ComponentInstance ci;
14753     OSType infoType;
14754     void * info;
14755 #ifndef SCSetInfo
14756     PyMac_PRECHECK(SCSetInfo);
14757 #endif
14758     if (!PyArg_ParseTuple(_args, "O&O&s",
14759                           CmpInstObj_Convert, &ci,
14760                           PyMac_GetOSType, &infoType,
14761                           &info))
14762         return NULL;
14763     _rv = SCSetInfo(ci,
14764                     infoType,
14765                     info);
14766     _res = Py_BuildValue("l",
14767                          _rv);
14768     return _res;
14769 }
14770
14771 static PyObject *Qt_SCSetCompressFlags(PyObject *_self, PyObject *_args)
14772 {
14773     PyObject *_res = NULL;
14774     ComponentResult _rv;
14775     ComponentInstance ci;
14776     long flags;
14777 #ifndef SCSetCompressFlags
14778     PyMac_PRECHECK(SCSetCompressFlags);
14779 #endif
14780     if (!PyArg_ParseTuple(_args, "O&l",
14781                           CmpInstObj_Convert, &ci,
14782                           &flags))
14783         return NULL;
14784     _rv = SCSetCompressFlags(ci,
14785                              flags);
14786     _res = Py_BuildValue("l",
14787                          _rv);
14788     return _res;
14789 }
14790
14791 static PyObject *Qt_SCGetCompressFlags(PyObject *_self, PyObject *_args)
14792 {
14793     PyObject *_res = NULL;
14794     ComponentResult _rv;
14795     ComponentInstance ci;
14796     long flags;
14797 #ifndef SCGetCompressFlags
14798     PyMac_PRECHECK(SCGetCompressFlags);
14799 #endif
14800     if (!PyArg_ParseTuple(_args, "O&",
14801                           CmpInstObj_Convert, &ci))
14802         return NULL;
14803     _rv = SCGetCompressFlags(ci,
14804                              &flags);
14805     _res = Py_BuildValue("ll",
14806                          _rv,
14807                          flags);
14808     return _res;
14809 }
14810
14811 static PyObject *Qt_SCGetSettingsAsText(PyObject *_self, PyObject *_args)
14812 {
14813     PyObject *_res = NULL;
14814     ComponentResult _rv;
14815     ComponentInstance ci;
14816     Handle text;
14817 #ifndef SCGetSettingsAsText
14818     PyMac_PRECHECK(SCGetSettingsAsText);
14819 #endif
14820     if (!PyArg_ParseTuple(_args, "O&",
14821                           CmpInstObj_Convert, &ci))
14822         return NULL;
14823     _rv = SCGetSettingsAsText(ci,
14824                               &text);
14825     _res = Py_BuildValue("lO&",
14826                          _rv,
14827                          ResObj_New, text);
14828     return _res;
14829 }
14830
14831 static PyObject *Qt_SCAsyncIdle(PyObject *_self, PyObject *_args)
14832 {
14833     PyObject *_res = NULL;
14834     ComponentResult _rv;
14835     ComponentInstance ci;
14836 #ifndef SCAsyncIdle
14837     PyMac_PRECHECK(SCAsyncIdle);
14838 #endif
14839     if (!PyArg_ParseTuple(_args, "O&",
14840                           CmpInstObj_Convert, &ci))
14841         return NULL;
14842     _rv = SCAsyncIdle(ci);
14843     _res = Py_BuildValue("l",
14844                          _rv);
14845     return _res;
14846 }
14847
14848 static PyObject *Qt_TweenerReset(PyObject *_self, PyObject *_args)
14849 {
14850     PyObject *_res = NULL;
14851     ComponentResult _rv;
14852     TweenerComponent tc;
14853 #ifndef TweenerReset
14854     PyMac_PRECHECK(TweenerReset);
14855 #endif
14856     if (!PyArg_ParseTuple(_args, "O&",
14857                           CmpInstObj_Convert, &tc))
14858         return NULL;
14859     _rv = TweenerReset(tc);
14860     _res = Py_BuildValue("l",
14861                          _rv);
14862     return _res;
14863 }
14864
14865 static PyObject *Qt_TCGetSourceRef(PyObject *_self, PyObject *_args)
14866 {
14867     PyObject *_res = NULL;
14868     HandlerError _rv;
14869     MediaHandler mh;
14870     TimeCodeDescriptionHandle tcdH;
14871     UserData srefH;
14872 #ifndef TCGetSourceRef
14873     PyMac_PRECHECK(TCGetSourceRef);
14874 #endif
14875     if (!PyArg_ParseTuple(_args, "O&O&",
14876                           CmpInstObj_Convert, &mh,
14877                           ResObj_Convert, &tcdH))
14878         return NULL;
14879     _rv = TCGetSourceRef(mh,
14880                          tcdH,
14881                          &srefH);
14882     _res = Py_BuildValue("lO&",
14883                          _rv,
14884                          UserDataObj_New, srefH);
14885     return _res;
14886 }
14887
14888 static PyObject *Qt_TCSetSourceRef(PyObject *_self, PyObject *_args)
14889 {
14890     PyObject *_res = NULL;
14891     HandlerError _rv;
14892     MediaHandler mh;
14893     TimeCodeDescriptionHandle tcdH;
14894     UserData srefH;
14895 #ifndef TCSetSourceRef
14896     PyMac_PRECHECK(TCSetSourceRef);
14897 #endif
14898     if (!PyArg_ParseTuple(_args, "O&O&O&",
14899                           CmpInstObj_Convert, &mh,
14900                           ResObj_Convert, &tcdH,
14901                           UserDataObj_Convert, &srefH))
14902         return NULL;
14903     _rv = TCSetSourceRef(mh,
14904                          tcdH,
14905                          srefH);
14906     _res = Py_BuildValue("l",
14907                          _rv);
14908     return _res;
14909 }
14910
14911 static PyObject *Qt_TCSetTimeCodeFlags(PyObject *_self, PyObject *_args)
14912 {
14913     PyObject *_res = NULL;
14914     HandlerError _rv;
14915     MediaHandler mh;
14916     long flags;
14917     long flagsMask;
14918 #ifndef TCSetTimeCodeFlags
14919     PyMac_PRECHECK(TCSetTimeCodeFlags);
14920 #endif
14921     if (!PyArg_ParseTuple(_args, "O&ll",
14922                           CmpInstObj_Convert, &mh,
14923                           &flags,
14924                           &flagsMask))
14925         return NULL;
14926     _rv = TCSetTimeCodeFlags(mh,
14927                              flags,
14928                              flagsMask);
14929     _res = Py_BuildValue("l",
14930                          _rv);
14931     return _res;
14932 }
14933
14934 static PyObject *Qt_TCGetTimeCodeFlags(PyObject *_self, PyObject *_args)
14935 {
14936     PyObject *_res = NULL;
14937     HandlerError _rv;
14938     MediaHandler mh;
14939     long flags;
14940 #ifndef TCGetTimeCodeFlags
14941     PyMac_PRECHECK(TCGetTimeCodeFlags);
14942 #endif
14943     if (!PyArg_ParseTuple(_args, "O&",
14944                           CmpInstObj_Convert, &mh))
14945         return NULL;
14946     _rv = TCGetTimeCodeFlags(mh,
14947                              &flags);
14948     _res = Py_BuildValue("ll",
14949                          _rv,
14950                          flags);
14951     return _res;
14952 }
14953
14954 static PyObject *Qt_MovieImportHandle(PyObject *_self, PyObject *_args)
14955 {
14956     PyObject *_res = NULL;
14957     ComponentResult _rv;
14958     MovieImportComponent ci;
14959     Handle dataH;
14960     Movie theMovie;
14961     Track targetTrack;
14962     Track usedTrack;
14963     TimeValue atTime;
14964     TimeValue addedDuration;
14965     long inFlags;
14966     long outFlags;
14967 #ifndef MovieImportHandle
14968     PyMac_PRECHECK(MovieImportHandle);
14969 #endif
14970     if (!PyArg_ParseTuple(_args, "O&O&O&O&ll",
14971                           CmpInstObj_Convert, &ci,
14972                           ResObj_Convert, &dataH,
14973                           MovieObj_Convert, &theMovie,
14974                           TrackObj_Convert, &targetTrack,
14975                           &atTime,
14976                           &inFlags))
14977         return NULL;
14978     _rv = MovieImportHandle(ci,
14979                             dataH,
14980                             theMovie,
14981                             targetTrack,
14982                             &usedTrack,
14983                             atTime,
14984                             &addedDuration,
14985                             inFlags,
14986                             &outFlags);
14987     _res = Py_BuildValue("lO&ll",
14988                          _rv,
14989                          TrackObj_New, usedTrack,
14990                          addedDuration,
14991                          outFlags);
14992     return _res;
14993 }
14994
14995 static PyObject *Qt_MovieImportFile(PyObject *_self, PyObject *_args)
14996 {
14997     PyObject *_res = NULL;
14998     ComponentResult _rv;
14999     MovieImportComponent ci;
15000     FSSpec theFile;
15001     Movie theMovie;
15002     Track targetTrack;
15003     Track usedTrack;
15004     TimeValue atTime;
15005     TimeValue addedDuration;
15006     long inFlags;
15007     long outFlags;
15008 #ifndef MovieImportFile
15009     PyMac_PRECHECK(MovieImportFile);
15010 #endif
15011     if (!PyArg_ParseTuple(_args, "O&O&O&O&ll",
15012                           CmpInstObj_Convert, &ci,
15013                           PyMac_GetFSSpec, &theFile,
15014                           MovieObj_Convert, &theMovie,
15015                           TrackObj_Convert, &targetTrack,
15016                           &atTime,
15017                           &inFlags))
15018         return NULL;
15019     _rv = MovieImportFile(ci,
15020                           &theFile,
15021                           theMovie,
15022                           targetTrack,
15023                           &usedTrack,
15024                           atTime,
15025                           &addedDuration,
15026                           inFlags,
15027                           &outFlags);
15028     _res = Py_BuildValue("lO&ll",
15029                          _rv,
15030                          TrackObj_New, usedTrack,
15031                          addedDuration,
15032                          outFlags);
15033     return _res;
15034 }
15035
15036 static PyObject *Qt_MovieImportSetSampleDuration(PyObject *_self, PyObject *_args)
15037 {
15038     PyObject *_res = NULL;
15039     ComponentResult _rv;
15040     MovieImportComponent ci;
15041     TimeValue duration;
15042     TimeScale scale;
15043 #ifndef MovieImportSetSampleDuration
15044     PyMac_PRECHECK(MovieImportSetSampleDuration);
15045 #endif
15046     if (!PyArg_ParseTuple(_args, "O&ll",
15047                           CmpInstObj_Convert, &ci,
15048                           &duration,
15049                           &scale))
15050         return NULL;
15051     _rv = MovieImportSetSampleDuration(ci,
15052                                        duration,
15053                                        scale);
15054     _res = Py_BuildValue("l",
15055                          _rv);
15056     return _res;
15057 }
15058
15059 static PyObject *Qt_MovieImportSetSampleDescription(PyObject *_self, PyObject *_args)
15060 {
15061     PyObject *_res = NULL;
15062     ComponentResult _rv;
15063     MovieImportComponent ci;
15064     SampleDescriptionHandle desc;
15065     OSType mediaType;
15066 #ifndef MovieImportSetSampleDescription
15067     PyMac_PRECHECK(MovieImportSetSampleDescription);
15068 #endif
15069     if (!PyArg_ParseTuple(_args, "O&O&O&",
15070                           CmpInstObj_Convert, &ci,
15071                           ResObj_Convert, &desc,
15072                           PyMac_GetOSType, &mediaType))
15073         return NULL;
15074     _rv = MovieImportSetSampleDescription(ci,
15075                                           desc,
15076                                           mediaType);
15077     _res = Py_BuildValue("l",
15078                          _rv);
15079     return _res;
15080 }
15081
15082 static PyObject *Qt_MovieImportSetMediaFile(PyObject *_self, PyObject *_args)
15083 {
15084     PyObject *_res = NULL;
15085     ComponentResult _rv;
15086     MovieImportComponent ci;
15087     AliasHandle alias;
15088 #ifndef MovieImportSetMediaFile
15089     PyMac_PRECHECK(MovieImportSetMediaFile);
15090 #endif
15091     if (!PyArg_ParseTuple(_args, "O&O&",
15092                           CmpInstObj_Convert, &ci,
15093                           ResObj_Convert, &alias))
15094         return NULL;
15095     _rv = MovieImportSetMediaFile(ci,
15096                                   alias);
15097     _res = Py_BuildValue("l",
15098                          _rv);
15099     return _res;
15100 }
15101
15102 static PyObject *Qt_MovieImportSetDimensions(PyObject *_self, PyObject *_args)
15103 {
15104     PyObject *_res = NULL;
15105     ComponentResult _rv;
15106     MovieImportComponent ci;
15107     Fixed width;
15108     Fixed height;
15109 #ifndef MovieImportSetDimensions
15110     PyMac_PRECHECK(MovieImportSetDimensions);
15111 #endif
15112     if (!PyArg_ParseTuple(_args, "O&O&O&",
15113                           CmpInstObj_Convert, &ci,
15114                           PyMac_GetFixed, &width,
15115                           PyMac_GetFixed, &height))
15116         return NULL;
15117     _rv = MovieImportSetDimensions(ci,
15118                                    width,
15119                                    height);
15120     _res = Py_BuildValue("l",
15121                          _rv);
15122     return _res;
15123 }
15124
15125 static PyObject *Qt_MovieImportSetChunkSize(PyObject *_self, PyObject *_args)
15126 {
15127     PyObject *_res = NULL;
15128     ComponentResult _rv;
15129     MovieImportComponent ci;
15130     long chunkSize;
15131 #ifndef MovieImportSetChunkSize
15132     PyMac_PRECHECK(MovieImportSetChunkSize);
15133 #endif
15134     if (!PyArg_ParseTuple(_args, "O&l",
15135                           CmpInstObj_Convert, &ci,
15136                           &chunkSize))
15137         return NULL;
15138     _rv = MovieImportSetChunkSize(ci,
15139                                   chunkSize);
15140     _res = Py_BuildValue("l",
15141                          _rv);
15142     return _res;
15143 }
15144
15145 static PyObject *Qt_MovieImportSetAuxiliaryData(PyObject *_self, PyObject *_args)
15146 {
15147     PyObject *_res = NULL;
15148     ComponentResult _rv;
15149     MovieImportComponent ci;
15150     Handle data;
15151     OSType handleType;
15152 #ifndef MovieImportSetAuxiliaryData
15153     PyMac_PRECHECK(MovieImportSetAuxiliaryData);
15154 #endif
15155     if (!PyArg_ParseTuple(_args, "O&O&O&",
15156                           CmpInstObj_Convert, &ci,
15157                           ResObj_Convert, &data,
15158                           PyMac_GetOSType, &handleType))
15159         return NULL;
15160     _rv = MovieImportSetAuxiliaryData(ci,
15161                                       data,
15162                                       handleType);
15163     _res = Py_BuildValue("l",
15164                          _rv);
15165     return _res;
15166 }
15167
15168 static PyObject *Qt_MovieImportSetFromScrap(PyObject *_self, PyObject *_args)
15169 {
15170     PyObject *_res = NULL;
15171     ComponentResult _rv;
15172     MovieImportComponent ci;
15173     Boolean fromScrap;
15174 #ifndef MovieImportSetFromScrap
15175     PyMac_PRECHECK(MovieImportSetFromScrap);
15176 #endif
15177     if (!PyArg_ParseTuple(_args, "O&b",
15178                           CmpInstObj_Convert, &ci,
15179                           &fromScrap))
15180         return NULL;
15181     _rv = MovieImportSetFromScrap(ci,
15182                                   fromScrap);
15183     _res = Py_BuildValue("l",
15184                          _rv);
15185     return _res;
15186 }
15187
15188 static PyObject *Qt_MovieImportDoUserDialog(PyObject *_self, PyObject *_args)
15189 {
15190     PyObject *_res = NULL;
15191     ComponentResult _rv;
15192     MovieImportComponent ci;
15193     FSSpec theFile;
15194     Handle theData;
15195     Boolean canceled;
15196 #ifndef MovieImportDoUserDialog
15197     PyMac_PRECHECK(MovieImportDoUserDialog);
15198 #endif
15199     if (!PyArg_ParseTuple(_args, "O&O&O&",
15200                           CmpInstObj_Convert, &ci,
15201                           PyMac_GetFSSpec, &theFile,
15202                           ResObj_Convert, &theData))
15203         return NULL;
15204     _rv = MovieImportDoUserDialog(ci,
15205                                   &theFile,
15206                                   theData,
15207                                   &canceled);
15208     _res = Py_BuildValue("lb",
15209                          _rv,
15210                          canceled);
15211     return _res;
15212 }
15213
15214 static PyObject *Qt_MovieImportSetDuration(PyObject *_self, PyObject *_args)
15215 {
15216     PyObject *_res = NULL;
15217     ComponentResult _rv;
15218     MovieImportComponent ci;
15219     TimeValue duration;
15220 #ifndef MovieImportSetDuration
15221     PyMac_PRECHECK(MovieImportSetDuration);
15222 #endif
15223     if (!PyArg_ParseTuple(_args, "O&l",
15224                           CmpInstObj_Convert, &ci,
15225                           &duration))
15226         return NULL;
15227     _rv = MovieImportSetDuration(ci,
15228                                  duration);
15229     _res = Py_BuildValue("l",
15230                          _rv);
15231     return _res;
15232 }
15233
15234 static PyObject *Qt_MovieImportGetAuxiliaryDataType(PyObject *_self, PyObject *_args)
15235 {
15236     PyObject *_res = NULL;
15237     ComponentResult _rv;
15238     MovieImportComponent ci;
15239     OSType auxType;
15240 #ifndef MovieImportGetAuxiliaryDataType
15241     PyMac_PRECHECK(MovieImportGetAuxiliaryDataType);
15242 #endif
15243     if (!PyArg_ParseTuple(_args, "O&",
15244                           CmpInstObj_Convert, &ci))
15245         return NULL;
15246     _rv = MovieImportGetAuxiliaryDataType(ci,
15247                                           &auxType);
15248     _res = Py_BuildValue("lO&",
15249                          _rv,
15250                          PyMac_BuildOSType, auxType);
15251     return _res;
15252 }
15253
15254 static PyObject *Qt_MovieImportValidate(PyObject *_self, PyObject *_args)
15255 {
15256     PyObject *_res = NULL;
15257     ComponentResult _rv;
15258     MovieImportComponent ci;
15259     FSSpec theFile;
15260     Handle theData;
15261     Boolean valid;
15262 #ifndef MovieImportValidate
15263     PyMac_PRECHECK(MovieImportValidate);
15264 #endif
15265     if (!PyArg_ParseTuple(_args, "O&O&O&",
15266                           CmpInstObj_Convert, &ci,
15267                           PyMac_GetFSSpec, &theFile,
15268                           ResObj_Convert, &theData))
15269         return NULL;
15270     _rv = MovieImportValidate(ci,
15271                               &theFile,
15272                               theData,
15273                               &valid);
15274     _res = Py_BuildValue("lb",
15275                          _rv,
15276                          valid);
15277     return _res;
15278 }
15279
15280 static PyObject *Qt_MovieImportGetFileType(PyObject *_self, PyObject *_args)
15281 {
15282     PyObject *_res = NULL;
15283     ComponentResult _rv;
15284     MovieImportComponent ci;
15285     OSType fileType;
15286 #ifndef MovieImportGetFileType
15287     PyMac_PRECHECK(MovieImportGetFileType);
15288 #endif
15289     if (!PyArg_ParseTuple(_args, "O&",
15290                           CmpInstObj_Convert, &ci))
15291         return NULL;
15292     _rv = MovieImportGetFileType(ci,
15293                                  &fileType);
15294     _res = Py_BuildValue("lO&",
15295                          _rv,
15296                          PyMac_BuildOSType, fileType);
15297     return _res;
15298 }
15299
15300 static PyObject *Qt_MovieImportDataRef(PyObject *_self, PyObject *_args)
15301 {
15302     PyObject *_res = NULL;
15303     ComponentResult _rv;
15304     MovieImportComponent ci;
15305     Handle dataRef;
15306     OSType dataRefType;
15307     Movie theMovie;
15308     Track targetTrack;
15309     Track usedTrack;
15310     TimeValue atTime;
15311     TimeValue addedDuration;
15312     long inFlags;
15313     long outFlags;
15314 #ifndef MovieImportDataRef
15315     PyMac_PRECHECK(MovieImportDataRef);
15316 #endif
15317     if (!PyArg_ParseTuple(_args, "O&O&O&O&O&ll",
15318                           CmpInstObj_Convert, &ci,
15319                           ResObj_Convert, &dataRef,
15320                           PyMac_GetOSType, &dataRefType,
15321                           MovieObj_Convert, &theMovie,
15322                           TrackObj_Convert, &targetTrack,
15323                           &atTime,
15324                           &inFlags))
15325         return NULL;
15326     _rv = MovieImportDataRef(ci,
15327                              dataRef,
15328                              dataRefType,
15329                              theMovie,
15330                              targetTrack,
15331                              &usedTrack,
15332                              atTime,
15333                              &addedDuration,
15334                              inFlags,
15335                              &outFlags);
15336     _res = Py_BuildValue("lO&ll",
15337                          _rv,
15338                          TrackObj_New, usedTrack,
15339                          addedDuration,
15340                          outFlags);
15341     return _res;
15342 }
15343
15344 static PyObject *Qt_MovieImportGetSampleDescription(PyObject *_self, PyObject *_args)
15345 {
15346     PyObject *_res = NULL;
15347     ComponentResult _rv;
15348     MovieImportComponent ci;
15349     SampleDescriptionHandle desc;
15350     OSType mediaType;
15351 #ifndef MovieImportGetSampleDescription
15352     PyMac_PRECHECK(MovieImportGetSampleDescription);
15353 #endif
15354     if (!PyArg_ParseTuple(_args, "O&",
15355                           CmpInstObj_Convert, &ci))
15356         return NULL;
15357     _rv = MovieImportGetSampleDescription(ci,
15358                                           &desc,
15359                                           &mediaType);
15360     _res = Py_BuildValue("lO&O&",
15361                          _rv,
15362                          ResObj_New, desc,
15363                          PyMac_BuildOSType, mediaType);
15364     return _res;
15365 }
15366
15367 static PyObject *Qt_MovieImportSetOffsetAndLimit(PyObject *_self, PyObject *_args)
15368 {
15369     PyObject *_res = NULL;
15370     ComponentResult _rv;
15371     MovieImportComponent ci;
15372     unsigned long offset;
15373     unsigned long limit;
15374 #ifndef MovieImportSetOffsetAndLimit
15375     PyMac_PRECHECK(MovieImportSetOffsetAndLimit);
15376 #endif
15377     if (!PyArg_ParseTuple(_args, "O&ll",
15378                           CmpInstObj_Convert, &ci,
15379                           &offset,
15380                           &limit))
15381         return NULL;
15382     _rv = MovieImportSetOffsetAndLimit(ci,
15383                                        offset,
15384                                        limit);
15385     _res = Py_BuildValue("l",
15386                          _rv);
15387     return _res;
15388 }
15389
15390 static PyObject *Qt_MovieImportSetOffsetAndLimit64(PyObject *_self, PyObject *_args)
15391 {
15392     PyObject *_res = NULL;
15393     ComponentResult _rv;
15394     MovieImportComponent ci;
15395     wide offset;
15396     wide limit;
15397 #ifndef MovieImportSetOffsetAndLimit64
15398     PyMac_PRECHECK(MovieImportSetOffsetAndLimit64);
15399 #endif
15400     if (!PyArg_ParseTuple(_args, "O&O&O&",
15401                           CmpInstObj_Convert, &ci,
15402                           PyMac_Getwide, &offset,
15403                           PyMac_Getwide, &limit))
15404         return NULL;
15405     _rv = MovieImportSetOffsetAndLimit64(ci,
15406                                          &offset,
15407                                          &limit);
15408     _res = Py_BuildValue("l",
15409                          _rv);
15410     return _res;
15411 }
15412
15413 static PyObject *Qt_MovieImportIdle(PyObject *_self, PyObject *_args)
15414 {
15415     PyObject *_res = NULL;
15416     ComponentResult _rv;
15417     MovieImportComponent ci;
15418     long inFlags;
15419     long outFlags;
15420 #ifndef MovieImportIdle
15421     PyMac_PRECHECK(MovieImportIdle);
15422 #endif
15423     if (!PyArg_ParseTuple(_args, "O&l",
15424                           CmpInstObj_Convert, &ci,
15425                           &inFlags))
15426         return NULL;
15427     _rv = MovieImportIdle(ci,
15428                           inFlags,
15429                           &outFlags);
15430     _res = Py_BuildValue("ll",
15431                          _rv,
15432                          outFlags);
15433     return _res;
15434 }
15435
15436 static PyObject *Qt_MovieImportValidateDataRef(PyObject *_self, PyObject *_args)
15437 {
15438     PyObject *_res = NULL;
15439     ComponentResult _rv;
15440     MovieImportComponent ci;
15441     Handle dataRef;
15442     OSType dataRefType;
15443     UInt8 valid;
15444 #ifndef MovieImportValidateDataRef
15445     PyMac_PRECHECK(MovieImportValidateDataRef);
15446 #endif
15447     if (!PyArg_ParseTuple(_args, "O&O&O&",
15448                           CmpInstObj_Convert, &ci,
15449                           ResObj_Convert, &dataRef,
15450                           PyMac_GetOSType, &dataRefType))
15451         return NULL;
15452     _rv = MovieImportValidateDataRef(ci,
15453                                      dataRef,
15454                                      dataRefType,
15455                                      &valid);
15456     _res = Py_BuildValue("lb",
15457                          _rv,
15458                          valid);
15459     return _res;
15460 }
15461
15462 static PyObject *Qt_MovieImportGetLoadState(PyObject *_self, PyObject *_args)
15463 {
15464     PyObject *_res = NULL;
15465     ComponentResult _rv;
15466     MovieImportComponent ci;
15467     long importerLoadState;
15468 #ifndef MovieImportGetLoadState
15469     PyMac_PRECHECK(MovieImportGetLoadState);
15470 #endif
15471     if (!PyArg_ParseTuple(_args, "O&",
15472                           CmpInstObj_Convert, &ci))
15473         return NULL;
15474     _rv = MovieImportGetLoadState(ci,
15475                                   &importerLoadState);
15476     _res = Py_BuildValue("ll",
15477                          _rv,
15478                          importerLoadState);
15479     return _res;
15480 }
15481
15482 static PyObject *Qt_MovieImportGetMaxLoadedTime(PyObject *_self, PyObject *_args)
15483 {
15484     PyObject *_res = NULL;
15485     ComponentResult _rv;
15486     MovieImportComponent ci;
15487     TimeValue time;
15488 #ifndef MovieImportGetMaxLoadedTime
15489     PyMac_PRECHECK(MovieImportGetMaxLoadedTime);
15490 #endif
15491     if (!PyArg_ParseTuple(_args, "O&",
15492                           CmpInstObj_Convert, &ci))
15493         return NULL;
15494     _rv = MovieImportGetMaxLoadedTime(ci,
15495                                       &time);
15496     _res = Py_BuildValue("ll",
15497                          _rv,
15498                          time);
15499     return _res;
15500 }
15501
15502 static PyObject *Qt_MovieImportEstimateCompletionTime(PyObject *_self, PyObject *_args)
15503 {
15504     PyObject *_res = NULL;
15505     ComponentResult _rv;
15506     MovieImportComponent ci;
15507     TimeRecord time;
15508 #ifndef MovieImportEstimateCompletionTime
15509     PyMac_PRECHECK(MovieImportEstimateCompletionTime);
15510 #endif
15511     if (!PyArg_ParseTuple(_args, "O&",
15512                           CmpInstObj_Convert, &ci))
15513         return NULL;
15514     _rv = MovieImportEstimateCompletionTime(ci,
15515                                             &time);
15516     _res = Py_BuildValue("lO&",
15517                          _rv,
15518                          QtTimeRecord_New, &time);
15519     return _res;
15520 }
15521
15522 static PyObject *Qt_MovieImportSetDontBlock(PyObject *_self, PyObject *_args)
15523 {
15524     PyObject *_res = NULL;
15525     ComponentResult _rv;
15526     MovieImportComponent ci;
15527     Boolean dontBlock;
15528 #ifndef MovieImportSetDontBlock
15529     PyMac_PRECHECK(MovieImportSetDontBlock);
15530 #endif
15531     if (!PyArg_ParseTuple(_args, "O&b",
15532                           CmpInstObj_Convert, &ci,
15533                           &dontBlock))
15534         return NULL;
15535     _rv = MovieImportSetDontBlock(ci,
15536                                   dontBlock);
15537     _res = Py_BuildValue("l",
15538                          _rv);
15539     return _res;
15540 }
15541
15542 static PyObject *Qt_MovieImportGetDontBlock(PyObject *_self, PyObject *_args)
15543 {
15544     PyObject *_res = NULL;
15545     ComponentResult _rv;
15546     MovieImportComponent ci;
15547     Boolean willBlock;
15548 #ifndef MovieImportGetDontBlock
15549     PyMac_PRECHECK(MovieImportGetDontBlock);
15550 #endif
15551     if (!PyArg_ParseTuple(_args, "O&",
15552                           CmpInstObj_Convert, &ci))
15553         return NULL;
15554     _rv = MovieImportGetDontBlock(ci,
15555                                   &willBlock);
15556     _res = Py_BuildValue("lb",
15557                          _rv,
15558                          willBlock);
15559     return _res;
15560 }
15561
15562 static PyObject *Qt_MovieImportSetIdleManager(PyObject *_self, PyObject *_args)
15563 {
15564     PyObject *_res = NULL;
15565     ComponentResult _rv;
15566     MovieImportComponent ci;
15567     IdleManager im;
15568 #ifndef MovieImportSetIdleManager
15569     PyMac_PRECHECK(MovieImportSetIdleManager);
15570 #endif
15571     if (!PyArg_ParseTuple(_args, "O&O&",
15572                           CmpInstObj_Convert, &ci,
15573                           IdleManagerObj_Convert, &im))
15574         return NULL;
15575     _rv = MovieImportSetIdleManager(ci,
15576                                     im);
15577     _res = Py_BuildValue("l",
15578                          _rv);
15579     return _res;
15580 }
15581
15582 static PyObject *Qt_MovieImportSetNewMovieFlags(PyObject *_self, PyObject *_args)
15583 {
15584     PyObject *_res = NULL;
15585     ComponentResult _rv;
15586     MovieImportComponent ci;
15587     long newMovieFlags;
15588 #ifndef MovieImportSetNewMovieFlags
15589     PyMac_PRECHECK(MovieImportSetNewMovieFlags);
15590 #endif
15591     if (!PyArg_ParseTuple(_args, "O&l",
15592                           CmpInstObj_Convert, &ci,
15593                           &newMovieFlags))
15594         return NULL;
15595     _rv = MovieImportSetNewMovieFlags(ci,
15596                                       newMovieFlags);
15597     _res = Py_BuildValue("l",
15598                          _rv);
15599     return _res;
15600 }
15601
15602 static PyObject *Qt_MovieImportGetDestinationMediaType(PyObject *_self, PyObject *_args)
15603 {
15604     PyObject *_res = NULL;
15605     ComponentResult _rv;
15606     MovieImportComponent ci;
15607     OSType mediaType;
15608 #ifndef MovieImportGetDestinationMediaType
15609     PyMac_PRECHECK(MovieImportGetDestinationMediaType);
15610 #endif
15611     if (!PyArg_ParseTuple(_args, "O&",
15612                           CmpInstObj_Convert, &ci))
15613         return NULL;
15614     _rv = MovieImportGetDestinationMediaType(ci,
15615                                              &mediaType);
15616     _res = Py_BuildValue("lO&",
15617                          _rv,
15618                          PyMac_BuildOSType, mediaType);
15619     return _res;
15620 }
15621
15622 static PyObject *Qt_MovieExportToHandle(PyObject *_self, PyObject *_args)
15623 {
15624     PyObject *_res = NULL;
15625     ComponentResult _rv;
15626     MovieExportComponent ci;
15627     Handle dataH;
15628     Movie theMovie;
15629     Track onlyThisTrack;
15630     TimeValue startTime;
15631     TimeValue duration;
15632 #ifndef MovieExportToHandle
15633     PyMac_PRECHECK(MovieExportToHandle);
15634 #endif
15635     if (!PyArg_ParseTuple(_args, "O&O&O&O&ll",
15636                           CmpInstObj_Convert, &ci,
15637                           ResObj_Convert, &dataH,
15638                           MovieObj_Convert, &theMovie,
15639                           TrackObj_Convert, &onlyThisTrack,
15640                           &startTime,
15641                           &duration))
15642         return NULL;
15643     _rv = MovieExportToHandle(ci,
15644                               dataH,
15645                               theMovie,
15646                               onlyThisTrack,
15647                               startTime,
15648                               duration);
15649     _res = Py_BuildValue("l",
15650                          _rv);
15651     return _res;
15652 }
15653
15654 static PyObject *Qt_MovieExportToFile(PyObject *_self, PyObject *_args)
15655 {
15656     PyObject *_res = NULL;
15657     ComponentResult _rv;
15658     MovieExportComponent ci;
15659     FSSpec theFile;
15660     Movie theMovie;
15661     Track onlyThisTrack;
15662     TimeValue startTime;
15663     TimeValue duration;
15664 #ifndef MovieExportToFile
15665     PyMac_PRECHECK(MovieExportToFile);
15666 #endif
15667     if (!PyArg_ParseTuple(_args, "O&O&O&O&ll",
15668                           CmpInstObj_Convert, &ci,
15669                           PyMac_GetFSSpec, &theFile,
15670                           MovieObj_Convert, &theMovie,
15671                           TrackObj_Convert, &onlyThisTrack,
15672                           &startTime,
15673                           &duration))
15674         return NULL;
15675     _rv = MovieExportToFile(ci,
15676                             &theFile,
15677                             theMovie,
15678                             onlyThisTrack,
15679                             startTime,
15680                             duration);
15681     _res = Py_BuildValue("l",
15682                          _rv);
15683     return _res;
15684 }
15685
15686 static PyObject *Qt_MovieExportGetAuxiliaryData(PyObject *_self, PyObject *_args)
15687 {
15688     PyObject *_res = NULL;
15689     ComponentResult _rv;
15690     MovieExportComponent ci;
15691     Handle dataH;
15692     OSType handleType;
15693 #ifndef MovieExportGetAuxiliaryData
15694     PyMac_PRECHECK(MovieExportGetAuxiliaryData);
15695 #endif
15696     if (!PyArg_ParseTuple(_args, "O&O&",
15697                           CmpInstObj_Convert, &ci,
15698                           ResObj_Convert, &dataH))
15699         return NULL;
15700     _rv = MovieExportGetAuxiliaryData(ci,
15701                                       dataH,
15702                                       &handleType);
15703     _res = Py_BuildValue("lO&",
15704                          _rv,
15705                          PyMac_BuildOSType, handleType);
15706     return _res;
15707 }
15708
15709 static PyObject *Qt_MovieExportSetSampleDescription(PyObject *_self, PyObject *_args)
15710 {
15711     PyObject *_res = NULL;
15712     ComponentResult _rv;
15713     MovieExportComponent ci;
15714     SampleDescriptionHandle desc;
15715     OSType mediaType;
15716 #ifndef MovieExportSetSampleDescription
15717     PyMac_PRECHECK(MovieExportSetSampleDescription);
15718 #endif
15719     if (!PyArg_ParseTuple(_args, "O&O&O&",
15720                           CmpInstObj_Convert, &ci,
15721                           ResObj_Convert, &desc,
15722                           PyMac_GetOSType, &mediaType))
15723         return NULL;
15724     _rv = MovieExportSetSampleDescription(ci,
15725                                           desc,
15726                                           mediaType);
15727     _res = Py_BuildValue("l",
15728                          _rv);
15729     return _res;
15730 }
15731
15732 static PyObject *Qt_MovieExportDoUserDialog(PyObject *_self, PyObject *_args)
15733 {
15734     PyObject *_res = NULL;
15735     ComponentResult _rv;
15736     MovieExportComponent ci;
15737     Movie theMovie;
15738     Track onlyThisTrack;
15739     TimeValue startTime;
15740     TimeValue duration;
15741     Boolean canceled;
15742 #ifndef MovieExportDoUserDialog
15743     PyMac_PRECHECK(MovieExportDoUserDialog);
15744 #endif
15745     if (!PyArg_ParseTuple(_args, "O&O&O&ll",
15746                           CmpInstObj_Convert, &ci,
15747                           MovieObj_Convert, &theMovie,
15748                           TrackObj_Convert, &onlyThisTrack,
15749                           &startTime,
15750                           &duration))
15751         return NULL;
15752     _rv = MovieExportDoUserDialog(ci,
15753                                   theMovie,
15754                                   onlyThisTrack,
15755                                   startTime,
15756                                   duration,
15757                                   &canceled);
15758     _res = Py_BuildValue("lb",
15759                          _rv,
15760                          canceled);
15761     return _res;
15762 }
15763
15764 static PyObject *Qt_MovieExportGetCreatorType(PyObject *_self, PyObject *_args)
15765 {
15766     PyObject *_res = NULL;
15767     ComponentResult _rv;
15768     MovieExportComponent ci;
15769     OSType creator;
15770 #ifndef MovieExportGetCreatorType
15771     PyMac_PRECHECK(MovieExportGetCreatorType);
15772 #endif
15773     if (!PyArg_ParseTuple(_args, "O&",
15774                           CmpInstObj_Convert, &ci))
15775         return NULL;
15776     _rv = MovieExportGetCreatorType(ci,
15777                                     &creator);
15778     _res = Py_BuildValue("lO&",
15779                          _rv,
15780                          PyMac_BuildOSType, creator);
15781     return _res;
15782 }
15783
15784 static PyObject *Qt_MovieExportToDataRef(PyObject *_self, PyObject *_args)
15785 {
15786     PyObject *_res = NULL;
15787     ComponentResult _rv;
15788     MovieExportComponent ci;
15789     Handle dataRef;
15790     OSType dataRefType;
15791     Movie theMovie;
15792     Track onlyThisTrack;
15793     TimeValue startTime;
15794     TimeValue duration;
15795 #ifndef MovieExportToDataRef
15796     PyMac_PRECHECK(MovieExportToDataRef);
15797 #endif
15798     if (!PyArg_ParseTuple(_args, "O&O&O&O&O&ll",
15799                           CmpInstObj_Convert, &ci,
15800                           ResObj_Convert, &dataRef,
15801                           PyMac_GetOSType, &dataRefType,
15802                           MovieObj_Convert, &theMovie,
15803                           TrackObj_Convert, &onlyThisTrack,
15804                           &startTime,
15805                           &duration))
15806         return NULL;
15807     _rv = MovieExportToDataRef(ci,
15808                                dataRef,
15809                                dataRefType,
15810                                theMovie,
15811                                onlyThisTrack,
15812                                startTime,
15813                                duration);
15814     _res = Py_BuildValue("l",
15815                          _rv);
15816     return _res;
15817 }
15818
15819 static PyObject *Qt_MovieExportFromProceduresToDataRef(PyObject *_self, PyObject *_args)
15820 {
15821     PyObject *_res = NULL;
15822     ComponentResult _rv;
15823     MovieExportComponent ci;
15824     Handle dataRef;
15825     OSType dataRefType;
15826 #ifndef MovieExportFromProceduresToDataRef
15827     PyMac_PRECHECK(MovieExportFromProceduresToDataRef);
15828 #endif
15829     if (!PyArg_ParseTuple(_args, "O&O&O&",
15830                           CmpInstObj_Convert, &ci,
15831                           ResObj_Convert, &dataRef,
15832                           PyMac_GetOSType, &dataRefType))
15833         return NULL;
15834     _rv = MovieExportFromProceduresToDataRef(ci,
15835                                              dataRef,
15836                                              dataRefType);
15837     _res = Py_BuildValue("l",
15838                          _rv);
15839     return _res;
15840 }
15841
15842 static PyObject *Qt_MovieExportValidate(PyObject *_self, PyObject *_args)
15843 {
15844     PyObject *_res = NULL;
15845     ComponentResult _rv;
15846     MovieExportComponent ci;
15847     Movie theMovie;
15848     Track onlyThisTrack;
15849     Boolean valid;
15850 #ifndef MovieExportValidate
15851     PyMac_PRECHECK(MovieExportValidate);
15852 #endif
15853     if (!PyArg_ParseTuple(_args, "O&O&O&",
15854                           CmpInstObj_Convert, &ci,
15855                           MovieObj_Convert, &theMovie,
15856                           TrackObj_Convert, &onlyThisTrack))
15857         return NULL;
15858     _rv = MovieExportValidate(ci,
15859                               theMovie,
15860                               onlyThisTrack,
15861                               &valid);
15862     _res = Py_BuildValue("lb",
15863                          _rv,
15864                          valid);
15865     return _res;
15866 }
15867
15868 static PyObject *Qt_MovieExportGetFileNameExtension(PyObject *_self, PyObject *_args)
15869 {
15870     PyObject *_res = NULL;
15871     ComponentResult _rv;
15872     MovieExportComponent ci;
15873     OSType extension;
15874 #ifndef MovieExportGetFileNameExtension
15875     PyMac_PRECHECK(MovieExportGetFileNameExtension);
15876 #endif
15877     if (!PyArg_ParseTuple(_args, "O&",
15878                           CmpInstObj_Convert, &ci))
15879         return NULL;
15880     _rv = MovieExportGetFileNameExtension(ci,
15881                                           &extension);
15882     _res = Py_BuildValue("lO&",
15883                          _rv,
15884                          PyMac_BuildOSType, extension);
15885     return _res;
15886 }
15887
15888 static PyObject *Qt_MovieExportGetShortFileTypeString(PyObject *_self, PyObject *_args)
15889 {
15890     PyObject *_res = NULL;
15891     ComponentResult _rv;
15892     MovieExportComponent ci;
15893     Str255 typeString;
15894 #ifndef MovieExportGetShortFileTypeString
15895     PyMac_PRECHECK(MovieExportGetShortFileTypeString);
15896 #endif
15897     if (!PyArg_ParseTuple(_args, "O&O&",
15898                           CmpInstObj_Convert, &ci,
15899                           PyMac_GetStr255, typeString))
15900         return NULL;
15901     _rv = MovieExportGetShortFileTypeString(ci,
15902                                             typeString);
15903     _res = Py_BuildValue("l",
15904                          _rv);
15905     return _res;
15906 }
15907
15908 static PyObject *Qt_MovieExportGetSourceMediaType(PyObject *_self, PyObject *_args)
15909 {
15910     PyObject *_res = NULL;
15911     ComponentResult _rv;
15912     MovieExportComponent ci;
15913     OSType mediaType;
15914 #ifndef MovieExportGetSourceMediaType
15915     PyMac_PRECHECK(MovieExportGetSourceMediaType);
15916 #endif
15917     if (!PyArg_ParseTuple(_args, "O&",
15918                           CmpInstObj_Convert, &ci))
15919         return NULL;
15920     _rv = MovieExportGetSourceMediaType(ci,
15921                                         &mediaType);
15922     _res = Py_BuildValue("lO&",
15923                          _rv,
15924                          PyMac_BuildOSType, mediaType);
15925     return _res;
15926 }
15927
15928 static PyObject *Qt_TextExportGetTimeFraction(PyObject *_self, PyObject *_args)
15929 {
15930     PyObject *_res = NULL;
15931     ComponentResult _rv;
15932     TextExportComponent ci;
15933     long movieTimeFraction;
15934 #ifndef TextExportGetTimeFraction
15935     PyMac_PRECHECK(TextExportGetTimeFraction);
15936 #endif
15937     if (!PyArg_ParseTuple(_args, "O&",
15938                           CmpInstObj_Convert, &ci))
15939         return NULL;
15940     _rv = TextExportGetTimeFraction(ci,
15941                                     &movieTimeFraction);
15942     _res = Py_BuildValue("ll",
15943                          _rv,
15944                          movieTimeFraction);
15945     return _res;
15946 }
15947
15948 static PyObject *Qt_TextExportSetTimeFraction(PyObject *_self, PyObject *_args)
15949 {
15950     PyObject *_res = NULL;
15951     ComponentResult _rv;
15952     TextExportComponent ci;
15953     long movieTimeFraction;
15954 #ifndef TextExportSetTimeFraction
15955     PyMac_PRECHECK(TextExportSetTimeFraction);
15956 #endif
15957     if (!PyArg_ParseTuple(_args, "O&l",
15958                           CmpInstObj_Convert, &ci,
15959                           &movieTimeFraction))
15960         return NULL;
15961     _rv = TextExportSetTimeFraction(ci,
15962                                     movieTimeFraction);
15963     _res = Py_BuildValue("l",
15964                          _rv);
15965     return _res;
15966 }
15967
15968 static PyObject *Qt_TextExportGetSettings(PyObject *_self, PyObject *_args)
15969 {
15970     PyObject *_res = NULL;
15971     ComponentResult _rv;
15972     TextExportComponent ci;
15973     long setting;
15974 #ifndef TextExportGetSettings
15975     PyMac_PRECHECK(TextExportGetSettings);
15976 #endif
15977     if (!PyArg_ParseTuple(_args, "O&",
15978                           CmpInstObj_Convert, &ci))
15979         return NULL;
15980     _rv = TextExportGetSettings(ci,
15981                                 &setting);
15982     _res = Py_BuildValue("ll",
15983                          _rv,
15984                          setting);
15985     return _res;
15986 }
15987
15988 static PyObject *Qt_TextExportSetSettings(PyObject *_self, PyObject *_args)
15989 {
15990     PyObject *_res = NULL;
15991     ComponentResult _rv;
15992     TextExportComponent ci;
15993     long setting;
15994 #ifndef TextExportSetSettings
15995     PyMac_PRECHECK(TextExportSetSettings);
15996 #endif
15997     if (!PyArg_ParseTuple(_args, "O&l",
15998                           CmpInstObj_Convert, &ci,
15999                           &setting))
16000         return NULL;
16001     _rv = TextExportSetSettings(ci,
16002                                 setting);
16003     _res = Py_BuildValue("l",
16004                          _rv);
16005     return _res;
16006 }
16007
16008 static PyObject *Qt_MIDIImportGetSettings(PyObject *_self, PyObject *_args)
16009 {
16010     PyObject *_res = NULL;
16011     ComponentResult _rv;
16012     TextExportComponent ci;
16013     long setting;
16014 #ifndef MIDIImportGetSettings
16015     PyMac_PRECHECK(MIDIImportGetSettings);
16016 #endif
16017     if (!PyArg_ParseTuple(_args, "O&",
16018                           CmpInstObj_Convert, &ci))
16019         return NULL;
16020     _rv = MIDIImportGetSettings(ci,
16021                                 &setting);
16022     _res = Py_BuildValue("ll",
16023                          _rv,
16024                          setting);
16025     return _res;
16026 }
16027
16028 static PyObject *Qt_MIDIImportSetSettings(PyObject *_self, PyObject *_args)
16029 {
16030     PyObject *_res = NULL;
16031     ComponentResult _rv;
16032     TextExportComponent ci;
16033     long setting;
16034 #ifndef MIDIImportSetSettings
16035     PyMac_PRECHECK(MIDIImportSetSettings);
16036 #endif
16037     if (!PyArg_ParseTuple(_args, "O&l",
16038                           CmpInstObj_Convert, &ci,
16039                           &setting))
16040         return NULL;
16041     _rv = MIDIImportSetSettings(ci,
16042                                 setting);
16043     _res = Py_BuildValue("l",
16044                          _rv);
16045     return _res;
16046 }
16047
16048 static PyObject *Qt_GraphicsImageImportSetSequenceEnabled(PyObject *_self, PyObject *_args)
16049 {
16050     PyObject *_res = NULL;
16051     ComponentResult _rv;
16052     GraphicImageMovieImportComponent ci;
16053     Boolean enable;
16054 #ifndef GraphicsImageImportSetSequenceEnabled
16055     PyMac_PRECHECK(GraphicsImageImportSetSequenceEnabled);
16056 #endif
16057     if (!PyArg_ParseTuple(_args, "O&b",
16058                           CmpInstObj_Convert, &ci,
16059                           &enable))
16060         return NULL;
16061     _rv = GraphicsImageImportSetSequenceEnabled(ci,
16062                                                 enable);
16063     _res = Py_BuildValue("l",
16064                          _rv);
16065     return _res;
16066 }
16067
16068 static PyObject *Qt_GraphicsImageImportGetSequenceEnabled(PyObject *_self, PyObject *_args)
16069 {
16070     PyObject *_res = NULL;
16071     ComponentResult _rv;
16072     GraphicImageMovieImportComponent ci;
16073     Boolean enable;
16074 #ifndef GraphicsImageImportGetSequenceEnabled
16075     PyMac_PRECHECK(GraphicsImageImportGetSequenceEnabled);
16076 #endif
16077     if (!PyArg_ParseTuple(_args, "O&",
16078                           CmpInstObj_Convert, &ci))
16079         return NULL;
16080     _rv = GraphicsImageImportGetSequenceEnabled(ci,
16081                                                 &enable);
16082     _res = Py_BuildValue("lb",
16083                          _rv,
16084                          enable);
16085     return _res;
16086 }
16087
16088 static PyObject *Qt_PreviewShowData(PyObject *_self, PyObject *_args)
16089 {
16090     PyObject *_res = NULL;
16091     ComponentResult _rv;
16092     pnotComponent p;
16093     OSType dataType;
16094     Handle data;
16095     Rect inHere;
16096 #ifndef PreviewShowData
16097     PyMac_PRECHECK(PreviewShowData);
16098 #endif
16099     if (!PyArg_ParseTuple(_args, "O&O&O&O&",
16100                           CmpInstObj_Convert, &p,
16101                           PyMac_GetOSType, &dataType,
16102                           ResObj_Convert, &data,
16103                           PyMac_GetRect, &inHere))
16104         return NULL;
16105     _rv = PreviewShowData(p,
16106                           dataType,
16107                           data,
16108                           &inHere);
16109     _res = Py_BuildValue("l",
16110                          _rv);
16111     return _res;
16112 }
16113
16114 static PyObject *Qt_PreviewMakePreviewReference(PyObject *_self, PyObject *_args)
16115 {
16116     PyObject *_res = NULL;
16117     ComponentResult _rv;
16118     pnotComponent p;
16119     OSType previewType;
16120     short resID;
16121     FSSpec sourceFile;
16122 #ifndef PreviewMakePreviewReference
16123     PyMac_PRECHECK(PreviewMakePreviewReference);
16124 #endif
16125     if (!PyArg_ParseTuple(_args, "O&O&",
16126                           CmpInstObj_Convert, &p,
16127                           PyMac_GetFSSpec, &sourceFile))
16128         return NULL;
16129     _rv = PreviewMakePreviewReference(p,
16130                                       &previewType,
16131                                       &resID,
16132                                       &sourceFile);
16133     _res = Py_BuildValue("lO&h",
16134                          _rv,
16135                          PyMac_BuildOSType, previewType,
16136                          resID);
16137     return _res;
16138 }
16139
16140 static PyObject *Qt_PreviewEvent(PyObject *_self, PyObject *_args)
16141 {
16142     PyObject *_res = NULL;
16143     ComponentResult _rv;
16144     pnotComponent p;
16145     EventRecord e;
16146     Boolean handledEvent;
16147 #ifndef PreviewEvent
16148     PyMac_PRECHECK(PreviewEvent);
16149 #endif
16150     if (!PyArg_ParseTuple(_args, "O&",
16151                           CmpInstObj_Convert, &p))
16152         return NULL;
16153     _rv = PreviewEvent(p,
16154                        &e,
16155                        &handledEvent);
16156     _res = Py_BuildValue("lO&b",
16157                          _rv,
16158                          PyMac_BuildEventRecord, &e,
16159                          handledEvent);
16160     return _res;
16161 }
16162
16163 static PyObject *Qt_DataCodecDecompress(PyObject *_self, PyObject *_args)
16164 {
16165     PyObject *_res = NULL;
16166     ComponentResult _rv;
16167     DataCodecComponent dc;
16168     void * srcData;
16169     UInt32 srcSize;
16170     void * dstData;
16171     UInt32 dstBufferSize;
16172 #ifndef DataCodecDecompress
16173     PyMac_PRECHECK(DataCodecDecompress);
16174 #endif
16175     if (!PyArg_ParseTuple(_args, "O&slsl",
16176                           CmpInstObj_Convert, &dc,
16177                           &srcData,
16178                           &srcSize,
16179                           &dstData,
16180                           &dstBufferSize))
16181         return NULL;
16182     _rv = DataCodecDecompress(dc,
16183                               srcData,
16184                               srcSize,
16185                               dstData,
16186                               dstBufferSize);
16187     _res = Py_BuildValue("l",
16188                          _rv);
16189     return _res;
16190 }
16191
16192 static PyObject *Qt_DataCodecGetCompressBufferSize(PyObject *_self, PyObject *_args)
16193 {
16194     PyObject *_res = NULL;
16195     ComponentResult _rv;
16196     DataCodecComponent dc;
16197     UInt32 srcSize;
16198     UInt32 dstSize;
16199 #ifndef DataCodecGetCompressBufferSize
16200     PyMac_PRECHECK(DataCodecGetCompressBufferSize);
16201 #endif
16202     if (!PyArg_ParseTuple(_args, "O&l",
16203                           CmpInstObj_Convert, &dc,
16204                           &srcSize))
16205         return NULL;
16206     _rv = DataCodecGetCompressBufferSize(dc,
16207                                          srcSize,
16208                                          &dstSize);
16209     _res = Py_BuildValue("ll",
16210                          _rv,
16211                          dstSize);
16212     return _res;
16213 }
16214
16215 static PyObject *Qt_DataCodecCompress(PyObject *_self, PyObject *_args)
16216 {
16217     PyObject *_res = NULL;
16218     ComponentResult _rv;
16219     DataCodecComponent dc;
16220     void * srcData;
16221     UInt32 srcSize;
16222     void * dstData;
16223     UInt32 dstBufferSize;
16224     UInt32 actualDstSize;
16225     UInt32 decompressSlop;
16226 #ifndef DataCodecCompress
16227     PyMac_PRECHECK(DataCodecCompress);
16228 #endif
16229     if (!PyArg_ParseTuple(_args, "O&slsl",
16230                           CmpInstObj_Convert, &dc,
16231                           &srcData,
16232                           &srcSize,
16233                           &dstData,
16234                           &dstBufferSize))
16235         return NULL;
16236     _rv = DataCodecCompress(dc,
16237                             srcData,
16238                             srcSize,
16239                             dstData,
16240                             dstBufferSize,
16241                             &actualDstSize,
16242                             &decompressSlop);
16243     _res = Py_BuildValue("lll",
16244                          _rv,
16245                          actualDstSize,
16246                          decompressSlop);
16247     return _res;
16248 }
16249
16250 static PyObject *Qt_DataCodecBeginInterruptSafe(PyObject *_self, PyObject *_args)
16251 {
16252     PyObject *_res = NULL;
16253     ComponentResult _rv;
16254     DataCodecComponent dc;
16255     unsigned long maxSrcSize;
16256 #ifndef DataCodecBeginInterruptSafe
16257     PyMac_PRECHECK(DataCodecBeginInterruptSafe);
16258 #endif
16259     if (!PyArg_ParseTuple(_args, "O&l",
16260                           CmpInstObj_Convert, &dc,
16261                           &maxSrcSize))
16262         return NULL;
16263     _rv = DataCodecBeginInterruptSafe(dc,
16264                                       maxSrcSize);
16265     _res = Py_BuildValue("l",
16266                          _rv);
16267     return _res;
16268 }
16269
16270 static PyObject *Qt_DataCodecEndInterruptSafe(PyObject *_self, PyObject *_args)
16271 {
16272     PyObject *_res = NULL;
16273     ComponentResult _rv;
16274     DataCodecComponent dc;
16275 #ifndef DataCodecEndInterruptSafe
16276     PyMac_PRECHECK(DataCodecEndInterruptSafe);
16277 #endif
16278     if (!PyArg_ParseTuple(_args, "O&",
16279                           CmpInstObj_Convert, &dc))
16280         return NULL;
16281     _rv = DataCodecEndInterruptSafe(dc);
16282     _res = Py_BuildValue("l",
16283                          _rv);
16284     return _res;
16285 }
16286
16287 static PyObject *Qt_DataHGetData(PyObject *_self, PyObject *_args)
16288 {
16289     PyObject *_res = NULL;
16290     ComponentResult _rv;
16291     DataHandler dh;
16292     Handle h;
16293     long hOffset;
16294     long offset;
16295     long size;
16296 #ifndef DataHGetData
16297     PyMac_PRECHECK(DataHGetData);
16298 #endif
16299     if (!PyArg_ParseTuple(_args, "O&O&lll",
16300                           CmpInstObj_Convert, &dh,
16301                           ResObj_Convert, &h,
16302                           &hOffset,
16303                           &offset,
16304                           &size))
16305         return NULL;
16306     _rv = DataHGetData(dh,
16307                        h,
16308                        hOffset,
16309                        offset,
16310                        size);
16311     _res = Py_BuildValue("l",
16312                          _rv);
16313     return _res;
16314 }
16315
16316 static PyObject *Qt_DataHPutData(PyObject *_self, PyObject *_args)
16317 {
16318     PyObject *_res = NULL;
16319     ComponentResult _rv;
16320     DataHandler dh;
16321     Handle h;
16322     long hOffset;
16323     long offset;
16324     long size;
16325 #ifndef DataHPutData
16326     PyMac_PRECHECK(DataHPutData);
16327 #endif
16328     if (!PyArg_ParseTuple(_args, "O&O&ll",
16329                           CmpInstObj_Convert, &dh,
16330                           ResObj_Convert, &h,
16331                           &hOffset,
16332                           &size))
16333         return NULL;
16334     _rv = DataHPutData(dh,
16335                        h,
16336                        hOffset,
16337                        &offset,
16338                        size);
16339     _res = Py_BuildValue("ll",
16340                          _rv,
16341                          offset);
16342     return _res;
16343 }
16344
16345 static PyObject *Qt_DataHFlushData(PyObject *_self, PyObject *_args)
16346 {
16347     PyObject *_res = NULL;
16348     ComponentResult _rv;
16349     DataHandler dh;
16350 #ifndef DataHFlushData
16351     PyMac_PRECHECK(DataHFlushData);
16352 #endif
16353     if (!PyArg_ParseTuple(_args, "O&",
16354                           CmpInstObj_Convert, &dh))
16355         return NULL;
16356     _rv = DataHFlushData(dh);
16357     _res = Py_BuildValue("l",
16358                          _rv);
16359     return _res;
16360 }
16361
16362 static PyObject *Qt_DataHOpenForWrite(PyObject *_self, PyObject *_args)
16363 {
16364     PyObject *_res = NULL;
16365     ComponentResult _rv;
16366     DataHandler dh;
16367 #ifndef DataHOpenForWrite
16368     PyMac_PRECHECK(DataHOpenForWrite);
16369 #endif
16370     if (!PyArg_ParseTuple(_args, "O&",
16371                           CmpInstObj_Convert, &dh))
16372         return NULL;
16373     _rv = DataHOpenForWrite(dh);
16374     _res = Py_BuildValue("l",
16375                          _rv);
16376     return _res;
16377 }
16378
16379 static PyObject *Qt_DataHCloseForWrite(PyObject *_self, PyObject *_args)
16380 {
16381     PyObject *_res = NULL;
16382     ComponentResult _rv;
16383     DataHandler dh;
16384 #ifndef DataHCloseForWrite
16385     PyMac_PRECHECK(DataHCloseForWrite);
16386 #endif
16387     if (!PyArg_ParseTuple(_args, "O&",
16388                           CmpInstObj_Convert, &dh))
16389         return NULL;
16390     _rv = DataHCloseForWrite(dh);
16391     _res = Py_BuildValue("l",
16392                          _rv);
16393     return _res;
16394 }
16395
16396 static PyObject *Qt_DataHOpenForRead(PyObject *_self, PyObject *_args)
16397 {
16398     PyObject *_res = NULL;
16399     ComponentResult _rv;
16400     DataHandler dh;
16401 #ifndef DataHOpenForRead
16402     PyMac_PRECHECK(DataHOpenForRead);
16403 #endif
16404     if (!PyArg_ParseTuple(_args, "O&",
16405                           CmpInstObj_Convert, &dh))
16406         return NULL;
16407     _rv = DataHOpenForRead(dh);
16408     _res = Py_BuildValue("l",
16409                          _rv);
16410     return _res;
16411 }
16412
16413 static PyObject *Qt_DataHCloseForRead(PyObject *_self, PyObject *_args)
16414 {
16415     PyObject *_res = NULL;
16416     ComponentResult _rv;
16417     DataHandler dh;
16418 #ifndef DataHCloseForRead
16419     PyMac_PRECHECK(DataHCloseForRead);
16420 #endif
16421     if (!PyArg_ParseTuple(_args, "O&",
16422                           CmpInstObj_Convert, &dh))
16423         return NULL;
16424     _rv = DataHCloseForRead(dh);
16425     _res = Py_BuildValue("l",
16426                          _rv);
16427     return _res;
16428 }
16429
16430 static PyObject *Qt_DataHSetDataRef(PyObject *_self, PyObject *_args)
16431 {
16432     PyObject *_res = NULL;
16433     ComponentResult _rv;
16434     DataHandler dh;
16435     Handle dataRef;
16436 #ifndef DataHSetDataRef
16437     PyMac_PRECHECK(DataHSetDataRef);
16438 #endif
16439     if (!PyArg_ParseTuple(_args, "O&O&",
16440                           CmpInstObj_Convert, &dh,
16441                           ResObj_Convert, &dataRef))
16442         return NULL;
16443     _rv = DataHSetDataRef(dh,
16444                           dataRef);
16445     _res = Py_BuildValue("l",
16446                          _rv);
16447     return _res;
16448 }
16449
16450 static PyObject *Qt_DataHGetDataRef(PyObject *_self, PyObject *_args)
16451 {
16452     PyObject *_res = NULL;
16453     ComponentResult _rv;
16454     DataHandler dh;
16455     Handle dataRef;
16456 #ifndef DataHGetDataRef
16457     PyMac_PRECHECK(DataHGetDataRef);
16458 #endif
16459     if (!PyArg_ParseTuple(_args, "O&",
16460                           CmpInstObj_Convert, &dh))
16461         return NULL;
16462     _rv = DataHGetDataRef(dh,
16463                           &dataRef);
16464     _res = Py_BuildValue("lO&",
16465                          _rv,
16466                          ResObj_New, dataRef);
16467     return _res;
16468 }
16469
16470 static PyObject *Qt_DataHCompareDataRef(PyObject *_self, PyObject *_args)
16471 {
16472     PyObject *_res = NULL;
16473     ComponentResult _rv;
16474     DataHandler dh;
16475     Handle dataRef;
16476     Boolean equal;
16477 #ifndef DataHCompareDataRef
16478     PyMac_PRECHECK(DataHCompareDataRef);
16479 #endif
16480     if (!PyArg_ParseTuple(_args, "O&O&",
16481                           CmpInstObj_Convert, &dh,
16482                           ResObj_Convert, &dataRef))
16483         return NULL;
16484     _rv = DataHCompareDataRef(dh,
16485                               dataRef,
16486                               &equal);
16487     _res = Py_BuildValue("lb",
16488                          _rv,
16489                          equal);
16490     return _res;
16491 }
16492
16493 static PyObject *Qt_DataHTask(PyObject *_self, PyObject *_args)
16494 {
16495     PyObject *_res = NULL;
16496     ComponentResult _rv;
16497     DataHandler dh;
16498 #ifndef DataHTask
16499     PyMac_PRECHECK(DataHTask);
16500 #endif
16501     if (!PyArg_ParseTuple(_args, "O&",
16502                           CmpInstObj_Convert, &dh))
16503         return NULL;
16504     _rv = DataHTask(dh);
16505     _res = Py_BuildValue("l",
16506                          _rv);
16507     return _res;
16508 }
16509
16510 static PyObject *Qt_DataHFinishData(PyObject *_self, PyObject *_args)
16511 {
16512     PyObject *_res = NULL;
16513     ComponentResult _rv;
16514     DataHandler dh;
16515     Ptr PlaceToPutDataPtr;
16516     Boolean Cancel;
16517 #ifndef DataHFinishData
16518     PyMac_PRECHECK(DataHFinishData);
16519 #endif
16520     if (!PyArg_ParseTuple(_args, "O&sb",
16521                           CmpInstObj_Convert, &dh,
16522                           &PlaceToPutDataPtr,
16523                           &Cancel))
16524         return NULL;
16525     _rv = DataHFinishData(dh,
16526                           PlaceToPutDataPtr,
16527                           Cancel);
16528     _res = Py_BuildValue("l",
16529                          _rv);
16530     return _res;
16531 }
16532
16533 static PyObject *Qt_DataHFlushCache(PyObject *_self, PyObject *_args)
16534 {
16535     PyObject *_res = NULL;
16536     ComponentResult _rv;
16537     DataHandler dh;
16538 #ifndef DataHFlushCache
16539     PyMac_PRECHECK(DataHFlushCache);
16540 #endif
16541     if (!PyArg_ParseTuple(_args, "O&",
16542                           CmpInstObj_Convert, &dh))
16543         return NULL;
16544     _rv = DataHFlushCache(dh);
16545     _res = Py_BuildValue("l",
16546                          _rv);
16547     return _res;
16548 }
16549
16550 static PyObject *Qt_DataHResolveDataRef(PyObject *_self, PyObject *_args)
16551 {
16552     PyObject *_res = NULL;
16553     ComponentResult _rv;
16554     DataHandler dh;
16555     Handle theDataRef;
16556     Boolean wasChanged;
16557     Boolean userInterfaceAllowed;
16558 #ifndef DataHResolveDataRef
16559     PyMac_PRECHECK(DataHResolveDataRef);
16560 #endif
16561     if (!PyArg_ParseTuple(_args, "O&O&b",
16562                           CmpInstObj_Convert, &dh,
16563                           ResObj_Convert, &theDataRef,
16564                           &userInterfaceAllowed))
16565         return NULL;
16566     _rv = DataHResolveDataRef(dh,
16567                               theDataRef,
16568                               &wasChanged,
16569                               userInterfaceAllowed);
16570     _res = Py_BuildValue("lb",
16571                          _rv,
16572                          wasChanged);
16573     return _res;
16574 }
16575
16576 static PyObject *Qt_DataHGetFileSize(PyObject *_self, PyObject *_args)
16577 {
16578     PyObject *_res = NULL;
16579     ComponentResult _rv;
16580     DataHandler dh;
16581     long fileSize;
16582 #ifndef DataHGetFileSize
16583     PyMac_PRECHECK(DataHGetFileSize);
16584 #endif
16585     if (!PyArg_ParseTuple(_args, "O&",
16586                           CmpInstObj_Convert, &dh))
16587         return NULL;
16588     _rv = DataHGetFileSize(dh,
16589                            &fileSize);
16590     _res = Py_BuildValue("ll",
16591                          _rv,
16592                          fileSize);
16593     return _res;
16594 }
16595
16596 static PyObject *Qt_DataHCanUseDataRef(PyObject *_self, PyObject *_args)
16597 {
16598     PyObject *_res = NULL;
16599     ComponentResult _rv;
16600     DataHandler dh;
16601     Handle dataRef;
16602     long useFlags;
16603 #ifndef DataHCanUseDataRef
16604     PyMac_PRECHECK(DataHCanUseDataRef);
16605 #endif
16606     if (!PyArg_ParseTuple(_args, "O&O&",
16607                           CmpInstObj_Convert, &dh,
16608                           ResObj_Convert, &dataRef))
16609         return NULL;
16610     _rv = DataHCanUseDataRef(dh,
16611                              dataRef,
16612                              &useFlags);
16613     _res = Py_BuildValue("ll",
16614                          _rv,
16615                          useFlags);
16616     return _res;
16617 }
16618
16619 static PyObject *Qt_DataHPreextend(PyObject *_self, PyObject *_args)
16620 {
16621     PyObject *_res = NULL;
16622     ComponentResult _rv;
16623     DataHandler dh;
16624     unsigned long maxToAdd;
16625     unsigned long spaceAdded;
16626 #ifndef DataHPreextend
16627     PyMac_PRECHECK(DataHPreextend);
16628 #endif
16629     if (!PyArg_ParseTuple(_args, "O&l",
16630                           CmpInstObj_Convert, &dh,
16631                           &maxToAdd))
16632         return NULL;
16633     _rv = DataHPreextend(dh,
16634                          maxToAdd,
16635                          &spaceAdded);
16636     _res = Py_BuildValue("ll",
16637                          _rv,
16638                          spaceAdded);
16639     return _res;
16640 }
16641
16642 static PyObject *Qt_DataHSetFileSize(PyObject *_self, PyObject *_args)
16643 {
16644     PyObject *_res = NULL;
16645     ComponentResult _rv;
16646     DataHandler dh;
16647     long fileSize;
16648 #ifndef DataHSetFileSize
16649     PyMac_PRECHECK(DataHSetFileSize);
16650 #endif
16651     if (!PyArg_ParseTuple(_args, "O&l",
16652                           CmpInstObj_Convert, &dh,
16653                           &fileSize))
16654         return NULL;
16655     _rv = DataHSetFileSize(dh,
16656                            fileSize);
16657     _res = Py_BuildValue("l",
16658                          _rv);
16659     return _res;
16660 }
16661
16662 static PyObject *Qt_DataHGetFreeSpace(PyObject *_self, PyObject *_args)
16663 {
16664     PyObject *_res = NULL;
16665     ComponentResult _rv;
16666     DataHandler dh;
16667     unsigned long freeSize;
16668 #ifndef DataHGetFreeSpace
16669     PyMac_PRECHECK(DataHGetFreeSpace);
16670 #endif
16671     if (!PyArg_ParseTuple(_args, "O&",
16672                           CmpInstObj_Convert, &dh))
16673         return NULL;
16674     _rv = DataHGetFreeSpace(dh,
16675                             &freeSize);
16676     _res = Py_BuildValue("ll",
16677                          _rv,
16678                          freeSize);
16679     return _res;
16680 }
16681
16682 static PyObject *Qt_DataHCreateFile(PyObject *_self, PyObject *_args)
16683 {
16684     PyObject *_res = NULL;
16685     ComponentResult _rv;
16686     DataHandler dh;
16687     OSType creator;
16688     Boolean deleteExisting;
16689 #ifndef DataHCreateFile
16690     PyMac_PRECHECK(DataHCreateFile);
16691 #endif
16692     if (!PyArg_ParseTuple(_args, "O&O&b",
16693                           CmpInstObj_Convert, &dh,
16694                           PyMac_GetOSType, &creator,
16695                           &deleteExisting))
16696         return NULL;
16697     _rv = DataHCreateFile(dh,
16698                           creator,
16699                           deleteExisting);
16700     _res = Py_BuildValue("l",
16701                          _rv);
16702     return _res;
16703 }
16704
16705 static PyObject *Qt_DataHGetPreferredBlockSize(PyObject *_self, PyObject *_args)
16706 {
16707     PyObject *_res = NULL;
16708     ComponentResult _rv;
16709     DataHandler dh;
16710     long blockSize;
16711 #ifndef DataHGetPreferredBlockSize
16712     PyMac_PRECHECK(DataHGetPreferredBlockSize);
16713 #endif
16714     if (!PyArg_ParseTuple(_args, "O&",
16715                           CmpInstObj_Convert, &dh))
16716         return NULL;
16717     _rv = DataHGetPreferredBlockSize(dh,
16718                                      &blockSize);
16719     _res = Py_BuildValue("ll",
16720                          _rv,
16721                          blockSize);
16722     return _res;
16723 }
16724
16725 static PyObject *Qt_DataHGetDeviceIndex(PyObject *_self, PyObject *_args)
16726 {
16727     PyObject *_res = NULL;
16728     ComponentResult _rv;
16729     DataHandler dh;
16730     long deviceIndex;
16731 #ifndef DataHGetDeviceIndex
16732     PyMac_PRECHECK(DataHGetDeviceIndex);
16733 #endif
16734     if (!PyArg_ParseTuple(_args, "O&",
16735                           CmpInstObj_Convert, &dh))
16736         return NULL;
16737     _rv = DataHGetDeviceIndex(dh,
16738                               &deviceIndex);
16739     _res = Py_BuildValue("ll",
16740                          _rv,
16741                          deviceIndex);
16742     return _res;
16743 }
16744
16745 static PyObject *Qt_DataHIsStreamingDataHandler(PyObject *_self, PyObject *_args)
16746 {
16747     PyObject *_res = NULL;
16748     ComponentResult _rv;
16749     DataHandler dh;
16750     Boolean yes;
16751 #ifndef DataHIsStreamingDataHandler
16752     PyMac_PRECHECK(DataHIsStreamingDataHandler);
16753 #endif
16754     if (!PyArg_ParseTuple(_args, "O&",
16755                           CmpInstObj_Convert, &dh))
16756         return NULL;
16757     _rv = DataHIsStreamingDataHandler(dh,
16758                                       &yes);
16759     _res = Py_BuildValue("lb",
16760                          _rv,
16761                          yes);
16762     return _res;
16763 }
16764
16765 static PyObject *Qt_DataHGetDataInBuffer(PyObject *_self, PyObject *_args)
16766 {
16767     PyObject *_res = NULL;
16768     ComponentResult _rv;
16769     DataHandler dh;
16770     long startOffset;
16771     long size;
16772 #ifndef DataHGetDataInBuffer
16773     PyMac_PRECHECK(DataHGetDataInBuffer);
16774 #endif
16775     if (!PyArg_ParseTuple(_args, "O&l",
16776                           CmpInstObj_Convert, &dh,
16777                           &startOffset))
16778         return NULL;
16779     _rv = DataHGetDataInBuffer(dh,
16780                                startOffset,
16781                                &size);
16782     _res = Py_BuildValue("ll",
16783                          _rv,
16784                          size);
16785     return _res;
16786 }
16787
16788 static PyObject *Qt_DataHGetScheduleAheadTime(PyObject *_self, PyObject *_args)
16789 {
16790     PyObject *_res = NULL;
16791     ComponentResult _rv;
16792     DataHandler dh;
16793     long millisecs;
16794 #ifndef DataHGetScheduleAheadTime
16795     PyMac_PRECHECK(DataHGetScheduleAheadTime);
16796 #endif
16797     if (!PyArg_ParseTuple(_args, "O&",
16798                           CmpInstObj_Convert, &dh))
16799         return NULL;
16800     _rv = DataHGetScheduleAheadTime(dh,
16801                                     &millisecs);
16802     _res = Py_BuildValue("ll",
16803                          _rv,
16804                          millisecs);
16805     return _res;
16806 }
16807
16808 static PyObject *Qt_DataHSetCacheSizeLimit(PyObject *_self, PyObject *_args)
16809 {
16810     PyObject *_res = NULL;
16811     ComponentResult _rv;
16812     DataHandler dh;
16813     Size cacheSizeLimit;
16814 #ifndef DataHSetCacheSizeLimit
16815     PyMac_PRECHECK(DataHSetCacheSizeLimit);
16816 #endif
16817     if (!PyArg_ParseTuple(_args, "O&l",
16818                           CmpInstObj_Convert, &dh,
16819                           &cacheSizeLimit))
16820         return NULL;
16821     _rv = DataHSetCacheSizeLimit(dh,
16822                                  cacheSizeLimit);
16823     _res = Py_BuildValue("l",
16824                          _rv);
16825     return _res;
16826 }
16827
16828 static PyObject *Qt_DataHGetCacheSizeLimit(PyObject *_self, PyObject *_args)
16829 {
16830     PyObject *_res = NULL;
16831     ComponentResult _rv;
16832     DataHandler dh;
16833     Size cacheSizeLimit;
16834 #ifndef DataHGetCacheSizeLimit
16835     PyMac_PRECHECK(DataHGetCacheSizeLimit);
16836 #endif
16837     if (!PyArg_ParseTuple(_args, "O&",
16838                           CmpInstObj_Convert, &dh))
16839         return NULL;
16840     _rv = DataHGetCacheSizeLimit(dh,
16841                                  &cacheSizeLimit);
16842     _res = Py_BuildValue("ll",
16843                          _rv,
16844                          cacheSizeLimit);
16845     return _res;
16846 }
16847
16848 static PyObject *Qt_DataHGetMovie(PyObject *_self, PyObject *_args)
16849 {
16850     PyObject *_res = NULL;
16851     ComponentResult _rv;
16852     DataHandler dh;
16853     Movie theMovie;
16854     short id;
16855 #ifndef DataHGetMovie
16856     PyMac_PRECHECK(DataHGetMovie);
16857 #endif
16858     if (!PyArg_ParseTuple(_args, "O&",
16859                           CmpInstObj_Convert, &dh))
16860         return NULL;
16861     _rv = DataHGetMovie(dh,
16862                         &theMovie,
16863                         &id);
16864     _res = Py_BuildValue("lO&h",
16865                          _rv,
16866                          MovieObj_New, theMovie,
16867                          id);
16868     return _res;
16869 }
16870
16871 static PyObject *Qt_DataHAddMovie(PyObject *_self, PyObject *_args)
16872 {
16873     PyObject *_res = NULL;
16874     ComponentResult _rv;
16875     DataHandler dh;
16876     Movie theMovie;
16877     short id;
16878 #ifndef DataHAddMovie
16879     PyMac_PRECHECK(DataHAddMovie);
16880 #endif
16881     if (!PyArg_ParseTuple(_args, "O&O&",
16882                           CmpInstObj_Convert, &dh,
16883                           MovieObj_Convert, &theMovie))
16884         return NULL;
16885     _rv = DataHAddMovie(dh,
16886                         theMovie,
16887                         &id);
16888     _res = Py_BuildValue("lh",
16889                          _rv,
16890                          id);
16891     return _res;
16892 }
16893
16894 static PyObject *Qt_DataHUpdateMovie(PyObject *_self, PyObject *_args)
16895 {
16896     PyObject *_res = NULL;
16897     ComponentResult _rv;
16898     DataHandler dh;
16899     Movie theMovie;
16900     short id;
16901 #ifndef DataHUpdateMovie
16902     PyMac_PRECHECK(DataHUpdateMovie);
16903 #endif
16904     if (!PyArg_ParseTuple(_args, "O&O&h",
16905                           CmpInstObj_Convert, &dh,
16906                           MovieObj_Convert, &theMovie,
16907                           &id))
16908         return NULL;
16909     _rv = DataHUpdateMovie(dh,
16910                            theMovie,
16911                            id);
16912     _res = Py_BuildValue("l",
16913                          _rv);
16914     return _res;
16915 }
16916
16917 static PyObject *Qt_DataHDoesBuffer(PyObject *_self, PyObject *_args)
16918 {
16919     PyObject *_res = NULL;
16920     ComponentResult _rv;
16921     DataHandler dh;
16922     Boolean buffersReads;
16923     Boolean buffersWrites;
16924 #ifndef DataHDoesBuffer
16925     PyMac_PRECHECK(DataHDoesBuffer);
16926 #endif
16927     if (!PyArg_ParseTuple(_args, "O&",
16928                           CmpInstObj_Convert, &dh))
16929         return NULL;
16930     _rv = DataHDoesBuffer(dh,
16931                           &buffersReads,
16932                           &buffersWrites);
16933     _res = Py_BuildValue("lbb",
16934                          _rv,
16935                          buffersReads,
16936                          buffersWrites);
16937     return _res;
16938 }
16939
16940 static PyObject *Qt_DataHGetFileName(PyObject *_self, PyObject *_args)
16941 {
16942     PyObject *_res = NULL;
16943     ComponentResult _rv;
16944     DataHandler dh;
16945     Str255 str;
16946 #ifndef DataHGetFileName
16947     PyMac_PRECHECK(DataHGetFileName);
16948 #endif
16949     if (!PyArg_ParseTuple(_args, "O&O&",
16950                           CmpInstObj_Convert, &dh,
16951                           PyMac_GetStr255, str))
16952         return NULL;
16953     _rv = DataHGetFileName(dh,
16954                            str);
16955     _res = Py_BuildValue("l",
16956                          _rv);
16957     return _res;
16958 }
16959
16960 static PyObject *Qt_DataHGetAvailableFileSize(PyObject *_self, PyObject *_args)
16961 {
16962     PyObject *_res = NULL;
16963     ComponentResult _rv;
16964     DataHandler dh;
16965     long fileSize;
16966 #ifndef DataHGetAvailableFileSize
16967     PyMac_PRECHECK(DataHGetAvailableFileSize);
16968 #endif
16969     if (!PyArg_ParseTuple(_args, "O&",
16970                           CmpInstObj_Convert, &dh))
16971         return NULL;
16972     _rv = DataHGetAvailableFileSize(dh,
16973                                     &fileSize);
16974     _res = Py_BuildValue("ll",
16975                          _rv,
16976                          fileSize);
16977     return _res;
16978 }
16979
16980 static PyObject *Qt_DataHGetMacOSFileType(PyObject *_self, PyObject *_args)
16981 {
16982     PyObject *_res = NULL;
16983     ComponentResult _rv;
16984     DataHandler dh;
16985     OSType fileType;
16986 #ifndef DataHGetMacOSFileType
16987     PyMac_PRECHECK(DataHGetMacOSFileType);
16988 #endif
16989     if (!PyArg_ParseTuple(_args, "O&",
16990                           CmpInstObj_Convert, &dh))
16991         return NULL;
16992     _rv = DataHGetMacOSFileType(dh,
16993                                 &fileType);
16994     _res = Py_BuildValue("lO&",
16995                          _rv,
16996                          PyMac_BuildOSType, fileType);
16997     return _res;
16998 }
16999
17000 static PyObject *Qt_DataHGetMIMEType(PyObject *_self, PyObject *_args)
17001 {
17002     PyObject *_res = NULL;
17003     ComponentResult _rv;
17004     DataHandler dh;
17005     Str255 mimeType;
17006 #ifndef DataHGetMIMEType
17007     PyMac_PRECHECK(DataHGetMIMEType);
17008 #endif
17009     if (!PyArg_ParseTuple(_args, "O&O&",
17010                           CmpInstObj_Convert, &dh,
17011                           PyMac_GetStr255, mimeType))
17012         return NULL;
17013     _rv = DataHGetMIMEType(dh,
17014                            mimeType);
17015     _res = Py_BuildValue("l",
17016                          _rv);
17017     return _res;
17018 }
17019
17020 static PyObject *Qt_DataHSetDataRefWithAnchor(PyObject *_self, PyObject *_args)
17021 {
17022     PyObject *_res = NULL;
17023     ComponentResult _rv;
17024     DataHandler dh;
17025     Handle anchorDataRef;
17026     OSType dataRefType;
17027     Handle dataRef;
17028 #ifndef DataHSetDataRefWithAnchor
17029     PyMac_PRECHECK(DataHSetDataRefWithAnchor);
17030 #endif
17031     if (!PyArg_ParseTuple(_args, "O&O&O&O&",
17032                           CmpInstObj_Convert, &dh,
17033                           ResObj_Convert, &anchorDataRef,
17034                           PyMac_GetOSType, &dataRefType,
17035                           ResObj_Convert, &dataRef))
17036         return NULL;
17037     _rv = DataHSetDataRefWithAnchor(dh,
17038                                     anchorDataRef,
17039                                     dataRefType,
17040                                     dataRef);
17041     _res = Py_BuildValue("l",
17042                          _rv);
17043     return _res;
17044 }
17045
17046 static PyObject *Qt_DataHGetDataRefWithAnchor(PyObject *_self, PyObject *_args)
17047 {
17048     PyObject *_res = NULL;
17049     ComponentResult _rv;
17050     DataHandler dh;
17051     Handle anchorDataRef;
17052     OSType dataRefType;
17053     Handle dataRef;
17054 #ifndef DataHGetDataRefWithAnchor
17055     PyMac_PRECHECK(DataHGetDataRefWithAnchor);
17056 #endif
17057     if (!PyArg_ParseTuple(_args, "O&O&O&",
17058                           CmpInstObj_Convert, &dh,
17059                           ResObj_Convert, &anchorDataRef,
17060                           PyMac_GetOSType, &dataRefType))
17061         return NULL;
17062     _rv = DataHGetDataRefWithAnchor(dh,
17063                                     anchorDataRef,
17064                                     dataRefType,
17065                                     &dataRef);
17066     _res = Py_BuildValue("lO&",
17067                          _rv,
17068                          ResObj_New, dataRef);
17069     return _res;
17070 }
17071
17072 static PyObject *Qt_DataHSetMacOSFileType(PyObject *_self, PyObject *_args)
17073 {
17074     PyObject *_res = NULL;
17075     ComponentResult _rv;
17076     DataHandler dh;
17077     OSType fileType;
17078 #ifndef DataHSetMacOSFileType
17079     PyMac_PRECHECK(DataHSetMacOSFileType);
17080 #endif
17081     if (!PyArg_ParseTuple(_args, "O&O&",
17082                           CmpInstObj_Convert, &dh,
17083                           PyMac_GetOSType, &fileType))
17084         return NULL;
17085     _rv = DataHSetMacOSFileType(dh,
17086                                 fileType);
17087     _res = Py_BuildValue("l",
17088                          _rv);
17089     return _res;
17090 }
17091
17092 static PyObject *Qt_DataHSetTimeBase(PyObject *_self, PyObject *_args)
17093 {
17094     PyObject *_res = NULL;
17095     ComponentResult _rv;
17096     DataHandler dh;
17097     TimeBase tb;
17098 #ifndef DataHSetTimeBase
17099     PyMac_PRECHECK(DataHSetTimeBase);
17100 #endif
17101     if (!PyArg_ParseTuple(_args, "O&O&",
17102                           CmpInstObj_Convert, &dh,
17103                           TimeBaseObj_Convert, &tb))
17104         return NULL;
17105     _rv = DataHSetTimeBase(dh,
17106                            tb);
17107     _res = Py_BuildValue("l",
17108                          _rv);
17109     return _res;
17110 }
17111
17112 static PyObject *Qt_DataHGetInfoFlags(PyObject *_self, PyObject *_args)
17113 {
17114     PyObject *_res = NULL;
17115     ComponentResult _rv;
17116     DataHandler dh;
17117     UInt32 flags;
17118 #ifndef DataHGetInfoFlags
17119     PyMac_PRECHECK(DataHGetInfoFlags);
17120 #endif
17121     if (!PyArg_ParseTuple(_args, "O&",
17122                           CmpInstObj_Convert, &dh))
17123         return NULL;
17124     _rv = DataHGetInfoFlags(dh,
17125                             &flags);
17126     _res = Py_BuildValue("ll",
17127                          _rv,
17128                          flags);
17129     return _res;
17130 }
17131
17132 static PyObject *Qt_DataHGetFileSize64(PyObject *_self, PyObject *_args)
17133 {
17134     PyObject *_res = NULL;
17135     ComponentResult _rv;
17136     DataHandler dh;
17137     wide fileSize;
17138 #ifndef DataHGetFileSize64
17139     PyMac_PRECHECK(DataHGetFileSize64);
17140 #endif
17141     if (!PyArg_ParseTuple(_args, "O&",
17142                           CmpInstObj_Convert, &dh))
17143         return NULL;
17144     _rv = DataHGetFileSize64(dh,
17145                              &fileSize);
17146     _res = Py_BuildValue("lO&",
17147                          _rv,
17148                          PyMac_Buildwide, fileSize);
17149     return _res;
17150 }
17151
17152 static PyObject *Qt_DataHPreextend64(PyObject *_self, PyObject *_args)
17153 {
17154     PyObject *_res = NULL;
17155     ComponentResult _rv;
17156     DataHandler dh;
17157     wide maxToAdd;
17158     wide spaceAdded;
17159 #ifndef DataHPreextend64
17160     PyMac_PRECHECK(DataHPreextend64);
17161 #endif
17162     if (!PyArg_ParseTuple(_args, "O&O&",
17163                           CmpInstObj_Convert, &dh,
17164                           PyMac_Getwide, &maxToAdd))
17165         return NULL;
17166     _rv = DataHPreextend64(dh,
17167                            &maxToAdd,
17168                            &spaceAdded);
17169     _res = Py_BuildValue("lO&",
17170                          _rv,
17171                          PyMac_Buildwide, spaceAdded);
17172     return _res;
17173 }
17174
17175 static PyObject *Qt_DataHSetFileSize64(PyObject *_self, PyObject *_args)
17176 {
17177     PyObject *_res = NULL;
17178     ComponentResult _rv;
17179     DataHandler dh;
17180     wide fileSize;
17181 #ifndef DataHSetFileSize64
17182     PyMac_PRECHECK(DataHSetFileSize64);
17183 #endif
17184     if (!PyArg_ParseTuple(_args, "O&O&",
17185                           CmpInstObj_Convert, &dh,
17186                           PyMac_Getwide, &fileSize))
17187         return NULL;
17188     _rv = DataHSetFileSize64(dh,
17189                              &fileSize);
17190     _res = Py_BuildValue("l",
17191                          _rv);
17192     return _res;
17193 }
17194
17195 static PyObject *Qt_DataHGetFreeSpace64(PyObject *_self, PyObject *_args)
17196 {
17197     PyObject *_res = NULL;
17198     ComponentResult _rv;
17199     DataHandler dh;
17200     wide freeSize;
17201 #ifndef DataHGetFreeSpace64
17202     PyMac_PRECHECK(DataHGetFreeSpace64);
17203 #endif
17204     if (!PyArg_ParseTuple(_args, "O&",
17205                           CmpInstObj_Convert, &dh))
17206         return NULL;
17207     _rv = DataHGetFreeSpace64(dh,
17208                               &freeSize);
17209     _res = Py_BuildValue("lO&",
17210                          _rv,
17211                          PyMac_Buildwide, freeSize);
17212     return _res;
17213 }
17214
17215 static PyObject *Qt_DataHAppend64(PyObject *_self, PyObject *_args)
17216 {
17217     PyObject *_res = NULL;
17218     ComponentResult _rv;
17219     DataHandler dh;
17220     void * data;
17221     wide fileOffset;
17222     unsigned long size;
17223 #ifndef DataHAppend64
17224     PyMac_PRECHECK(DataHAppend64);
17225 #endif
17226     if (!PyArg_ParseTuple(_args, "O&sl",
17227                           CmpInstObj_Convert, &dh,
17228                           &data,
17229                           &size))
17230         return NULL;
17231     _rv = DataHAppend64(dh,
17232                         data,
17233                         &fileOffset,
17234                         size);
17235     _res = Py_BuildValue("lO&",
17236                          _rv,
17237                          PyMac_Buildwide, fileOffset);
17238     return _res;
17239 }
17240
17241 static PyObject *Qt_DataHPollRead(PyObject *_self, PyObject *_args)
17242 {
17243     PyObject *_res = NULL;
17244     ComponentResult _rv;
17245     DataHandler dh;
17246     void * dataPtr;
17247     UInt32 dataSizeSoFar;
17248 #ifndef DataHPollRead
17249     PyMac_PRECHECK(DataHPollRead);
17250 #endif
17251     if (!PyArg_ParseTuple(_args, "O&s",
17252                           CmpInstObj_Convert, &dh,
17253                           &dataPtr))
17254         return NULL;
17255     _rv = DataHPollRead(dh,
17256                         dataPtr,
17257                         &dataSizeSoFar);
17258     _res = Py_BuildValue("ll",
17259                          _rv,
17260                          dataSizeSoFar);
17261     return _res;
17262 }
17263
17264 static PyObject *Qt_DataHGetDataAvailability(PyObject *_self, PyObject *_args)
17265 {
17266     PyObject *_res = NULL;
17267     ComponentResult _rv;
17268     DataHandler dh;
17269     long offset;
17270     long len;
17271     long missing_offset;
17272     long missing_len;
17273 #ifndef DataHGetDataAvailability
17274     PyMac_PRECHECK(DataHGetDataAvailability);
17275 #endif
17276     if (!PyArg_ParseTuple(_args, "O&ll",
17277                           CmpInstObj_Convert, &dh,
17278                           &offset,
17279                           &len))
17280         return NULL;
17281     _rv = DataHGetDataAvailability(dh,
17282                                    offset,
17283                                    len,
17284                                    &missing_offset,
17285                                    &missing_len);
17286     _res = Py_BuildValue("lll",
17287                          _rv,
17288                          missing_offset,
17289                          missing_len);
17290     return _res;
17291 }
17292
17293 static PyObject *Qt_DataHGetDataRefAsType(PyObject *_self, PyObject *_args)
17294 {
17295     PyObject *_res = NULL;
17296     ComponentResult _rv;
17297     DataHandler dh;
17298     OSType requestedType;
17299     Handle dataRef;
17300 #ifndef DataHGetDataRefAsType
17301     PyMac_PRECHECK(DataHGetDataRefAsType);
17302 #endif
17303     if (!PyArg_ParseTuple(_args, "O&O&",
17304                           CmpInstObj_Convert, &dh,
17305                           PyMac_GetOSType, &requestedType))
17306         return NULL;
17307     _rv = DataHGetDataRefAsType(dh,
17308                                 requestedType,
17309                                 &dataRef);
17310     _res = Py_BuildValue("lO&",
17311                          _rv,
17312                          ResObj_New, dataRef);
17313     return _res;
17314 }
17315
17316 static PyObject *Qt_DataHSetDataRefExtension(PyObject *_self, PyObject *_args)
17317 {
17318     PyObject *_res = NULL;
17319     ComponentResult _rv;
17320     DataHandler dh;
17321     Handle extension;
17322     OSType idType;
17323 #ifndef DataHSetDataRefExtension
17324     PyMac_PRECHECK(DataHSetDataRefExtension);
17325 #endif
17326     if (!PyArg_ParseTuple(_args, "O&O&O&",
17327                           CmpInstObj_Convert, &dh,
17328                           ResObj_Convert, &extension,
17329                           PyMac_GetOSType, &idType))
17330         return NULL;
17331     _rv = DataHSetDataRefExtension(dh,
17332                                    extension,
17333                                    idType);
17334     _res = Py_BuildValue("l",
17335                          _rv);
17336     return _res;
17337 }
17338
17339 static PyObject *Qt_DataHGetDataRefExtension(PyObject *_self, PyObject *_args)
17340 {
17341     PyObject *_res = NULL;
17342     ComponentResult _rv;
17343     DataHandler dh;
17344     Handle extension;
17345     OSType idType;
17346 #ifndef DataHGetDataRefExtension
17347     PyMac_PRECHECK(DataHGetDataRefExtension);
17348 #endif
17349     if (!PyArg_ParseTuple(_args, "O&O&",
17350                           CmpInstObj_Convert, &dh,
17351                           PyMac_GetOSType, &idType))
17352         return NULL;
17353     _rv = DataHGetDataRefExtension(dh,
17354                                    &extension,
17355                                    idType);
17356     _res = Py_BuildValue("lO&",
17357                          _rv,
17358                          ResObj_New, extension);
17359     return _res;
17360 }
17361
17362 static PyObject *Qt_DataHGetMovieWithFlags(PyObject *_self, PyObject *_args)
17363 {
17364     PyObject *_res = NULL;
17365     ComponentResult _rv;
17366     DataHandler dh;
17367     Movie theMovie;
17368     short id;
17369     short flags;
17370 #ifndef DataHGetMovieWithFlags
17371     PyMac_PRECHECK(DataHGetMovieWithFlags);
17372 #endif
17373     if (!PyArg_ParseTuple(_args, "O&h",
17374                           CmpInstObj_Convert, &dh,
17375                           &flags))
17376         return NULL;
17377     _rv = DataHGetMovieWithFlags(dh,
17378                                  &theMovie,
17379                                  &id,
17380                                  flags);
17381     _res = Py_BuildValue("lO&h",
17382                          _rv,
17383                          MovieObj_New, theMovie,
17384                          id);
17385     return _res;
17386 }
17387
17388 static PyObject *Qt_DataHGetFileTypeOrdering(PyObject *_self, PyObject *_args)
17389 {
17390     PyObject *_res = NULL;
17391     ComponentResult _rv;
17392     DataHandler dh;
17393     DataHFileTypeOrderingHandle orderingListHandle;
17394 #ifndef DataHGetFileTypeOrdering
17395     PyMac_PRECHECK(DataHGetFileTypeOrdering);
17396 #endif
17397     if (!PyArg_ParseTuple(_args, "O&",
17398                           CmpInstObj_Convert, &dh))
17399         return NULL;
17400     _rv = DataHGetFileTypeOrdering(dh,
17401                                    &orderingListHandle);
17402     _res = Py_BuildValue("lO&",
17403                          _rv,
17404                          ResObj_New, orderingListHandle);
17405     return _res;
17406 }
17407
17408 static PyObject *Qt_DataHCreateFileWithFlags(PyObject *_self, PyObject *_args)
17409 {
17410     PyObject *_res = NULL;
17411     ComponentResult _rv;
17412     DataHandler dh;
17413     OSType creator;
17414     Boolean deleteExisting;
17415     UInt32 flags;
17416 #ifndef DataHCreateFileWithFlags
17417     PyMac_PRECHECK(DataHCreateFileWithFlags);
17418 #endif
17419     if (!PyArg_ParseTuple(_args, "O&O&bl",
17420                           CmpInstObj_Convert, &dh,
17421                           PyMac_GetOSType, &creator,
17422                           &deleteExisting,
17423                           &flags))
17424         return NULL;
17425     _rv = DataHCreateFileWithFlags(dh,
17426                                    creator,
17427                                    deleteExisting,
17428                                    flags);
17429     _res = Py_BuildValue("l",
17430                          _rv);
17431     return _res;
17432 }
17433
17434 static PyObject *Qt_DataHGetInfo(PyObject *_self, PyObject *_args)
17435 {
17436     PyObject *_res = NULL;
17437     ComponentResult _rv;
17438     DataHandler dh;
17439     OSType what;
17440     void * info;
17441 #ifndef DataHGetInfo
17442     PyMac_PRECHECK(DataHGetInfo);
17443 #endif
17444     if (!PyArg_ParseTuple(_args, "O&O&s",
17445                           CmpInstObj_Convert, &dh,
17446                           PyMac_GetOSType, &what,
17447                           &info))
17448         return NULL;
17449     _rv = DataHGetInfo(dh,
17450                        what,
17451                        info);
17452     _res = Py_BuildValue("l",
17453                          _rv);
17454     return _res;
17455 }
17456
17457 static PyObject *Qt_DataHSetIdleManager(PyObject *_self, PyObject *_args)
17458 {
17459     PyObject *_res = NULL;
17460     ComponentResult _rv;
17461     DataHandler dh;
17462     IdleManager im;
17463 #ifndef DataHSetIdleManager
17464     PyMac_PRECHECK(DataHSetIdleManager);
17465 #endif
17466     if (!PyArg_ParseTuple(_args, "O&O&",
17467                           CmpInstObj_Convert, &dh,
17468                           IdleManagerObj_Convert, &im))
17469         return NULL;
17470     _rv = DataHSetIdleManager(dh,
17471                               im);
17472     _res = Py_BuildValue("l",
17473                          _rv);
17474     return _res;
17475 }
17476
17477 static PyObject *Qt_DataHDeleteFile(PyObject *_self, PyObject *_args)
17478 {
17479     PyObject *_res = NULL;
17480     ComponentResult _rv;
17481     DataHandler dh;
17482 #ifndef DataHDeleteFile
17483     PyMac_PRECHECK(DataHDeleteFile);
17484 #endif
17485     if (!PyArg_ParseTuple(_args, "O&",
17486                           CmpInstObj_Convert, &dh))
17487         return NULL;
17488     _rv = DataHDeleteFile(dh);
17489     _res = Py_BuildValue("l",
17490                          _rv);
17491     return _res;
17492 }
17493
17494 static PyObject *Qt_DataHSetMovieUsageFlags(PyObject *_self, PyObject *_args)
17495 {
17496     PyObject *_res = NULL;
17497     ComponentResult _rv;
17498     DataHandler dh;
17499     long flags;
17500 #ifndef DataHSetMovieUsageFlags
17501     PyMac_PRECHECK(DataHSetMovieUsageFlags);
17502 #endif
17503     if (!PyArg_ParseTuple(_args, "O&l",
17504                           CmpInstObj_Convert, &dh,
17505                           &flags))
17506         return NULL;
17507     _rv = DataHSetMovieUsageFlags(dh,
17508                                   flags);
17509     _res = Py_BuildValue("l",
17510                          _rv);
17511     return _res;
17512 }
17513
17514 static PyObject *Qt_DataHUseTemporaryDataRef(PyObject *_self, PyObject *_args)
17515 {
17516     PyObject *_res = NULL;
17517     ComponentResult _rv;
17518     DataHandler dh;
17519     long inFlags;
17520 #ifndef DataHUseTemporaryDataRef
17521     PyMac_PRECHECK(DataHUseTemporaryDataRef);
17522 #endif
17523     if (!PyArg_ParseTuple(_args, "O&l",
17524                           CmpInstObj_Convert, &dh,
17525                           &inFlags))
17526         return NULL;
17527     _rv = DataHUseTemporaryDataRef(dh,
17528                                    inFlags);
17529     _res = Py_BuildValue("l",
17530                          _rv);
17531     return _res;
17532 }
17533
17534 static PyObject *Qt_DataHGetTemporaryDataRefCapabilities(PyObject *_self, PyObject *_args)
17535 {
17536     PyObject *_res = NULL;
17537     ComponentResult _rv;
17538     DataHandler dh;
17539     long outUnderstoodFlags;
17540 #ifndef DataHGetTemporaryDataRefCapabilities
17541     PyMac_PRECHECK(DataHGetTemporaryDataRefCapabilities);
17542 #endif
17543     if (!PyArg_ParseTuple(_args, "O&",
17544                           CmpInstObj_Convert, &dh))
17545         return NULL;
17546     _rv = DataHGetTemporaryDataRefCapabilities(dh,
17547                                                &outUnderstoodFlags);
17548     _res = Py_BuildValue("ll",
17549                          _rv,
17550                          outUnderstoodFlags);
17551     return _res;
17552 }
17553
17554 static PyObject *Qt_DataHRenameFile(PyObject *_self, PyObject *_args)
17555 {
17556     PyObject *_res = NULL;
17557     ComponentResult _rv;
17558     DataHandler dh;
17559     Handle newDataRef;
17560 #ifndef DataHRenameFile
17561     PyMac_PRECHECK(DataHRenameFile);
17562 #endif
17563     if (!PyArg_ParseTuple(_args, "O&O&",
17564                           CmpInstObj_Convert, &dh,
17565                           ResObj_Convert, &newDataRef))
17566         return NULL;
17567     _rv = DataHRenameFile(dh,
17568                           newDataRef);
17569     _res = Py_BuildValue("l",
17570                          _rv);
17571     return _res;
17572 }
17573
17574 static PyObject *Qt_DataHPlaybackHints(PyObject *_self, PyObject *_args)
17575 {
17576     PyObject *_res = NULL;
17577     ComponentResult _rv;
17578     DataHandler dh;
17579     long flags;
17580     unsigned long minFileOffset;
17581     unsigned long maxFileOffset;
17582     long bytesPerSecond;
17583 #ifndef DataHPlaybackHints
17584     PyMac_PRECHECK(DataHPlaybackHints);
17585 #endif
17586     if (!PyArg_ParseTuple(_args, "O&llll",
17587                           CmpInstObj_Convert, &dh,
17588                           &flags,
17589                           &minFileOffset,
17590                           &maxFileOffset,
17591                           &bytesPerSecond))
17592         return NULL;
17593     _rv = DataHPlaybackHints(dh,
17594                              flags,
17595                              minFileOffset,
17596                              maxFileOffset,
17597                              bytesPerSecond);
17598     _res = Py_BuildValue("l",
17599                          _rv);
17600     return _res;
17601 }
17602
17603 static PyObject *Qt_DataHPlaybackHints64(PyObject *_self, PyObject *_args)
17604 {
17605     PyObject *_res = NULL;
17606     ComponentResult _rv;
17607     DataHandler dh;
17608     long flags;
17609     wide minFileOffset;
17610     wide maxFileOffset;
17611     long bytesPerSecond;
17612 #ifndef DataHPlaybackHints64
17613     PyMac_PRECHECK(DataHPlaybackHints64);
17614 #endif
17615     if (!PyArg_ParseTuple(_args, "O&lO&O&l",
17616                           CmpInstObj_Convert, &dh,
17617                           &flags,
17618                           PyMac_Getwide, &minFileOffset,
17619                           PyMac_Getwide, &maxFileOffset,
17620                           &bytesPerSecond))
17621         return NULL;
17622     _rv = DataHPlaybackHints64(dh,
17623                                flags,
17624                                &minFileOffset,
17625                                &maxFileOffset,
17626                                bytesPerSecond);
17627     _res = Py_BuildValue("l",
17628                          _rv);
17629     return _res;
17630 }
17631
17632 static PyObject *Qt_DataHGetDataRate(PyObject *_self, PyObject *_args)
17633 {
17634     PyObject *_res = NULL;
17635     ComponentResult _rv;
17636     DataHandler dh;
17637     long flags;
17638     long bytesPerSecond;
17639 #ifndef DataHGetDataRate
17640     PyMac_PRECHECK(DataHGetDataRate);
17641 #endif
17642     if (!PyArg_ParseTuple(_args, "O&l",
17643                           CmpInstObj_Convert, &dh,
17644                           &flags))
17645         return NULL;
17646     _rv = DataHGetDataRate(dh,
17647                            flags,
17648                            &bytesPerSecond);
17649     _res = Py_BuildValue("ll",
17650                          _rv,
17651                          bytesPerSecond);
17652     return _res;
17653 }
17654
17655 static PyObject *Qt_DataHSetTimeHints(PyObject *_self, PyObject *_args)
17656 {
17657     PyObject *_res = NULL;
17658     ComponentResult _rv;
17659     DataHandler dh;
17660     long flags;
17661     long bandwidthPriority;
17662     TimeScale scale;
17663     TimeValue minTime;
17664     TimeValue maxTime;
17665 #ifndef DataHSetTimeHints
17666     PyMac_PRECHECK(DataHSetTimeHints);
17667 #endif
17668     if (!PyArg_ParseTuple(_args, "O&lllll",
17669                           CmpInstObj_Convert, &dh,
17670                           &flags,
17671                           &bandwidthPriority,
17672                           &scale,
17673                           &minTime,
17674                           &maxTime))
17675         return NULL;
17676     _rv = DataHSetTimeHints(dh,
17677                             flags,
17678                             bandwidthPriority,
17679                             scale,
17680                             minTime,
17681                             maxTime);
17682     _res = Py_BuildValue("l",
17683                          _rv);
17684     return _res;
17685 }
17686
17687 static PyObject *Qt_VDGetMaxSrcRect(PyObject *_self, PyObject *_args)
17688 {
17689     PyObject *_res = NULL;
17690     ComponentResult _rv;
17691     VideoDigitizerComponent ci;
17692     short inputStd;
17693     Rect maxSrcRect;
17694 #ifndef VDGetMaxSrcRect
17695     PyMac_PRECHECK(VDGetMaxSrcRect);
17696 #endif
17697     if (!PyArg_ParseTuple(_args, "O&h",
17698                           CmpInstObj_Convert, &ci,
17699                           &inputStd))
17700         return NULL;
17701     _rv = VDGetMaxSrcRect(ci,
17702                           inputStd,
17703                           &maxSrcRect);
17704     _res = Py_BuildValue("lO&",
17705                          _rv,
17706                          PyMac_BuildRect, &maxSrcRect);
17707     return _res;
17708 }
17709
17710 static PyObject *Qt_VDGetActiveSrcRect(PyObject *_self, PyObject *_args)
17711 {
17712     PyObject *_res = NULL;
17713     ComponentResult _rv;
17714     VideoDigitizerComponent ci;
17715     short inputStd;
17716     Rect activeSrcRect;
17717 #ifndef VDGetActiveSrcRect
17718     PyMac_PRECHECK(VDGetActiveSrcRect);
17719 #endif
17720     if (!PyArg_ParseTuple(_args, "O&h",
17721                           CmpInstObj_Convert, &ci,
17722                           &inputStd))
17723         return NULL;
17724     _rv = VDGetActiveSrcRect(ci,
17725                              inputStd,
17726                              &activeSrcRect);
17727     _res = Py_BuildValue("lO&",
17728                          _rv,
17729                          PyMac_BuildRect, &activeSrcRect);
17730     return _res;
17731 }
17732
17733 static PyObject *Qt_VDSetDigitizerRect(PyObject *_self, PyObject *_args)
17734 {
17735     PyObject *_res = NULL;
17736     ComponentResult _rv;
17737     VideoDigitizerComponent ci;
17738     Rect digitizerRect;
17739 #ifndef VDSetDigitizerRect
17740     PyMac_PRECHECK(VDSetDigitizerRect);
17741 #endif
17742     if (!PyArg_ParseTuple(_args, "O&",
17743                           CmpInstObj_Convert, &ci))
17744         return NULL;
17745     _rv = VDSetDigitizerRect(ci,
17746                              &digitizerRect);
17747     _res = Py_BuildValue("lO&",
17748                          _rv,
17749                          PyMac_BuildRect, &digitizerRect);
17750     return _res;
17751 }
17752
17753 static PyObject *Qt_VDGetDigitizerRect(PyObject *_self, PyObject *_args)
17754 {
17755     PyObject *_res = NULL;
17756     ComponentResult _rv;
17757     VideoDigitizerComponent ci;
17758     Rect digitizerRect;
17759 #ifndef VDGetDigitizerRect
17760     PyMac_PRECHECK(VDGetDigitizerRect);
17761 #endif
17762     if (!PyArg_ParseTuple(_args, "O&",
17763                           CmpInstObj_Convert, &ci))
17764         return NULL;
17765     _rv = VDGetDigitizerRect(ci,
17766                              &digitizerRect);
17767     _res = Py_BuildValue("lO&",
17768                          _rv,
17769                          PyMac_BuildRect, &digitizerRect);
17770     return _res;
17771 }
17772
17773 static PyObject *Qt_VDGetVBlankRect(PyObject *_self, PyObject *_args)
17774 {
17775     PyObject *_res = NULL;
17776     ComponentResult _rv;
17777     VideoDigitizerComponent ci;
17778     short inputStd;
17779     Rect vBlankRect;
17780 #ifndef VDGetVBlankRect
17781     PyMac_PRECHECK(VDGetVBlankRect);
17782 #endif
17783     if (!PyArg_ParseTuple(_args, "O&h",
17784                           CmpInstObj_Convert, &ci,
17785                           &inputStd))
17786         return NULL;
17787     _rv = VDGetVBlankRect(ci,
17788                           inputStd,
17789                           &vBlankRect);
17790     _res = Py_BuildValue("lO&",
17791                          _rv,
17792                          PyMac_BuildRect, &vBlankRect);
17793     return _res;
17794 }
17795
17796 static PyObject *Qt_VDGetMaskPixMap(PyObject *_self, PyObject *_args)
17797 {
17798     PyObject *_res = NULL;
17799     ComponentResult _rv;
17800     VideoDigitizerComponent ci;
17801     PixMapHandle maskPixMap;
17802 #ifndef VDGetMaskPixMap
17803     PyMac_PRECHECK(VDGetMaskPixMap);
17804 #endif
17805     if (!PyArg_ParseTuple(_args, "O&O&",
17806                           CmpInstObj_Convert, &ci,
17807                           ResObj_Convert, &maskPixMap))
17808         return NULL;
17809     _rv = VDGetMaskPixMap(ci,
17810                           maskPixMap);
17811     _res = Py_BuildValue("l",
17812                          _rv);
17813     return _res;
17814 }
17815
17816 static PyObject *Qt_VDUseThisCLUT(PyObject *_self, PyObject *_args)
17817 {
17818     PyObject *_res = NULL;
17819     ComponentResult _rv;
17820     VideoDigitizerComponent ci;
17821     CTabHandle colorTableHandle;
17822 #ifndef VDUseThisCLUT
17823     PyMac_PRECHECK(VDUseThisCLUT);
17824 #endif
17825     if (!PyArg_ParseTuple(_args, "O&O&",
17826                           CmpInstObj_Convert, &ci,
17827                           ResObj_Convert, &colorTableHandle))
17828         return NULL;
17829     _rv = VDUseThisCLUT(ci,
17830                         colorTableHandle);
17831     _res = Py_BuildValue("l",
17832                          _rv);
17833     return _res;
17834 }
17835
17836 static PyObject *Qt_VDSetInputGammaValue(PyObject *_self, PyObject *_args)
17837 {
17838     PyObject *_res = NULL;
17839     ComponentResult _rv;
17840     VideoDigitizerComponent ci;
17841     Fixed channel1;
17842     Fixed channel2;
17843     Fixed channel3;
17844 #ifndef VDSetInputGammaValue
17845     PyMac_PRECHECK(VDSetInputGammaValue);
17846 #endif
17847     if (!PyArg_ParseTuple(_args, "O&O&O&O&",
17848                           CmpInstObj_Convert, &ci,
17849                           PyMac_GetFixed, &channel1,
17850                           PyMac_GetFixed, &channel2,
17851                           PyMac_GetFixed, &channel3))
17852         return NULL;
17853     _rv = VDSetInputGammaValue(ci,
17854                                channel1,
17855                                channel2,
17856                                channel3);
17857     _res = Py_BuildValue("l",
17858                          _rv);
17859     return _res;
17860 }
17861
17862 static PyObject *Qt_VDGetInputGammaValue(PyObject *_self, PyObject *_args)
17863 {
17864     PyObject *_res = NULL;
17865     ComponentResult _rv;
17866     VideoDigitizerComponent ci;
17867     Fixed channel1;
17868     Fixed channel2;
17869     Fixed channel3;
17870 #ifndef VDGetInputGammaValue
17871     PyMac_PRECHECK(VDGetInputGammaValue);
17872 #endif
17873     if (!PyArg_ParseTuple(_args, "O&",
17874                           CmpInstObj_Convert, &ci))
17875         return NULL;
17876     _rv = VDGetInputGammaValue(ci,
17877                                &channel1,
17878                                &channel2,
17879                                &channel3);
17880     _res = Py_BuildValue("lO&O&O&",
17881                          _rv,
17882                          PyMac_BuildFixed, channel1,
17883                          PyMac_BuildFixed, channel2,
17884                          PyMac_BuildFixed, channel3);
17885     return _res;
17886 }
17887
17888 static PyObject *Qt_VDSetBrightness(PyObject *_self, PyObject *_args)
17889 {
17890     PyObject *_res = NULL;
17891     ComponentResult _rv;
17892     VideoDigitizerComponent ci;
17893     unsigned short brightness;
17894 #ifndef VDSetBrightness
17895     PyMac_PRECHECK(VDSetBrightness);
17896 #endif
17897     if (!PyArg_ParseTuple(_args, "O&",
17898                           CmpInstObj_Convert, &ci))
17899         return NULL;
17900     _rv = VDSetBrightness(ci,
17901                           &brightness);
17902     _res = Py_BuildValue("lH",
17903                          _rv,
17904                          brightness);
17905     return _res;
17906 }
17907
17908 static PyObject *Qt_VDGetBrightness(PyObject *_self, PyObject *_args)
17909 {
17910     PyObject *_res = NULL;
17911     ComponentResult _rv;
17912     VideoDigitizerComponent ci;
17913     unsigned short brightness;
17914 #ifndef VDGetBrightness
17915     PyMac_PRECHECK(VDGetBrightness);
17916 #endif
17917     if (!PyArg_ParseTuple(_args, "O&",
17918                           CmpInstObj_Convert, &ci))
17919         return NULL;
17920     _rv = VDGetBrightness(ci,
17921                           &brightness);
17922     _res = Py_BuildValue("lH",
17923                          _rv,
17924                          brightness);
17925     return _res;
17926 }
17927
17928 static PyObject *Qt_VDSetContrast(PyObject *_self, PyObject *_args)
17929 {
17930     PyObject *_res = NULL;
17931     ComponentResult _rv;
17932     VideoDigitizerComponent ci;
17933     unsigned short contrast;
17934 #ifndef VDSetContrast
17935     PyMac_PRECHECK(VDSetContrast);
17936 #endif
17937     if (!PyArg_ParseTuple(_args, "O&",
17938                           CmpInstObj_Convert, &ci))
17939         return NULL;
17940     _rv = VDSetContrast(ci,
17941                         &contrast);
17942     _res = Py_BuildValue("lH",
17943                          _rv,
17944                          contrast);
17945     return _res;
17946 }
17947
17948 static PyObject *Qt_VDSetHue(PyObject *_self, PyObject *_args)
17949 {
17950     PyObject *_res = NULL;
17951     ComponentResult _rv;
17952     VideoDigitizerComponent ci;
17953     unsigned short hue;
17954 #ifndef VDSetHue
17955     PyMac_PRECHECK(VDSetHue);
17956 #endif
17957     if (!PyArg_ParseTuple(_args, "O&",
17958                           CmpInstObj_Convert, &ci))
17959         return NULL;
17960     _rv = VDSetHue(ci,
17961                    &hue);
17962     _res = Py_BuildValue("lH",
17963                          _rv,
17964                          hue);
17965     return _res;
17966 }
17967
17968 static PyObject *Qt_VDSetSharpness(PyObject *_self, PyObject *_args)
17969 {
17970     PyObject *_res = NULL;
17971     ComponentResult _rv;
17972     VideoDigitizerComponent ci;
17973     unsigned short sharpness;
17974 #ifndef VDSetSharpness
17975     PyMac_PRECHECK(VDSetSharpness);
17976 #endif
17977     if (!PyArg_ParseTuple(_args, "O&",
17978                           CmpInstObj_Convert, &ci))
17979         return NULL;
17980     _rv = VDSetSharpness(ci,
17981                          &sharpness);
17982     _res = Py_BuildValue("lH",
17983                          _rv,
17984                          sharpness);
17985     return _res;
17986 }
17987
17988 static PyObject *Qt_VDSetSaturation(PyObject *_self, PyObject *_args)
17989 {
17990     PyObject *_res = NULL;
17991     ComponentResult _rv;
17992     VideoDigitizerComponent ci;
17993     unsigned short saturation;
17994 #ifndef VDSetSaturation
17995     PyMac_PRECHECK(VDSetSaturation);
17996 #endif
17997     if (!PyArg_ParseTuple(_args, "O&",
17998                           CmpInstObj_Convert, &ci))
17999         return NULL;
18000     _rv = VDSetSaturation(ci,
18001                           &saturation);
18002     _res = Py_BuildValue("lH",
18003                          _rv,
18004                          saturation);
18005     return _res;
18006 }
18007
18008 static PyObject *Qt_VDGetContrast(PyObject *_self, PyObject *_args)
18009 {
18010     PyObject *_res = NULL;
18011     ComponentResult _rv;
18012     VideoDigitizerComponent ci;
18013     unsigned short contrast;
18014 #ifndef VDGetContrast
18015     PyMac_PRECHECK(VDGetContrast);
18016 #endif
18017     if (!PyArg_ParseTuple(_args, "O&",
18018                           CmpInstObj_Convert, &ci))
18019         return NULL;
18020     _rv = VDGetContrast(ci,
18021                         &contrast);
18022     _res = Py_BuildValue("lH",
18023                          _rv,
18024                          contrast);
18025     return _res;
18026 }
18027
18028 static PyObject *Qt_VDGetHue(PyObject *_self, PyObject *_args)
18029 {
18030     PyObject *_res = NULL;
18031     ComponentResult _rv;
18032     VideoDigitizerComponent ci;
18033     unsigned short hue;
18034 #ifndef VDGetHue
18035     PyMac_PRECHECK(VDGetHue);
18036 #endif
18037     if (!PyArg_ParseTuple(_args, "O&",
18038                           CmpInstObj_Convert, &ci))
18039         return NULL;
18040     _rv = VDGetHue(ci,
18041                    &hue);
18042     _res = Py_BuildValue("lH",
18043                          _rv,
18044                          hue);
18045     return _res;
18046 }
18047
18048 static PyObject *Qt_VDGetSharpness(PyObject *_self, PyObject *_args)
18049 {
18050     PyObject *_res = NULL;
18051     ComponentResult _rv;
18052     VideoDigitizerComponent ci;
18053     unsigned short sharpness;
18054 #ifndef VDGetSharpness
18055     PyMac_PRECHECK(VDGetSharpness);
18056 #endif
18057     if (!PyArg_ParseTuple(_args, "O&",
18058                           CmpInstObj_Convert, &ci))
18059         return NULL;
18060     _rv = VDGetSharpness(ci,
18061                          &sharpness);
18062     _res = Py_BuildValue("lH",
18063                          _rv,
18064                          sharpness);
18065     return _res;
18066 }
18067
18068 static PyObject *Qt_VDGetSaturation(PyObject *_self, PyObject *_args)
18069 {
18070     PyObject *_res = NULL;
18071     ComponentResult _rv;
18072     VideoDigitizerComponent ci;
18073     unsigned short saturation;
18074 #ifndef VDGetSaturation
18075     PyMac_PRECHECK(VDGetSaturation);
18076 #endif
18077     if (!PyArg_ParseTuple(_args, "O&",
18078                           CmpInstObj_Convert, &ci))
18079         return NULL;
18080     _rv = VDGetSaturation(ci,
18081                           &saturation);
18082     _res = Py_BuildValue("lH",
18083                          _rv,
18084                          saturation);
18085     return _res;
18086 }
18087
18088 static PyObject *Qt_VDGrabOneFrame(PyObject *_self, PyObject *_args)
18089 {
18090     PyObject *_res = NULL;
18091     ComponentResult _rv;
18092     VideoDigitizerComponent ci;
18093 #ifndef VDGrabOneFrame
18094     PyMac_PRECHECK(VDGrabOneFrame);
18095 #endif
18096     if (!PyArg_ParseTuple(_args, "O&",
18097                           CmpInstObj_Convert, &ci))
18098         return NULL;
18099     _rv = VDGrabOneFrame(ci);
18100     _res = Py_BuildValue("l",
18101                          _rv);
18102     return _res;
18103 }
18104
18105 static PyObject *Qt_VDGetMaxAuxBuffer(PyObject *_self, PyObject *_args)
18106 {
18107     PyObject *_res = NULL;
18108     ComponentResult _rv;
18109     VideoDigitizerComponent ci;
18110     PixMapHandle pm;
18111     Rect r;
18112 #ifndef VDGetMaxAuxBuffer
18113     PyMac_PRECHECK(VDGetMaxAuxBuffer);
18114 #endif
18115     if (!PyArg_ParseTuple(_args, "O&",
18116                           CmpInstObj_Convert, &ci))
18117         return NULL;
18118     _rv = VDGetMaxAuxBuffer(ci,
18119                             &pm,
18120                             &r);
18121     _res = Py_BuildValue("lO&O&",
18122                          _rv,
18123                          ResObj_New, pm,
18124                          PyMac_BuildRect, &r);
18125     return _res;
18126 }
18127
18128 static PyObject *Qt_VDGetCurrentFlags(PyObject *_self, PyObject *_args)
18129 {
18130     PyObject *_res = NULL;
18131     ComponentResult _rv;
18132     VideoDigitizerComponent ci;
18133     long inputCurrentFlag;
18134     long outputCurrentFlag;
18135 #ifndef VDGetCurrentFlags
18136     PyMac_PRECHECK(VDGetCurrentFlags);
18137 #endif
18138     if (!PyArg_ParseTuple(_args, "O&",
18139                           CmpInstObj_Convert, &ci))
18140         return NULL;
18141     _rv = VDGetCurrentFlags(ci,
18142                             &inputCurrentFlag,
18143                             &outputCurrentFlag);
18144     _res = Py_BuildValue("lll",
18145                          _rv,
18146                          inputCurrentFlag,
18147                          outputCurrentFlag);
18148     return _res;
18149 }
18150
18151 static PyObject *Qt_VDSetKeyColor(PyObject *_self, PyObject *_args)
18152 {
18153     PyObject *_res = NULL;
18154     ComponentResult _rv;
18155     VideoDigitizerComponent ci;
18156     long index;
18157 #ifndef VDSetKeyColor
18158     PyMac_PRECHECK(VDSetKeyColor);
18159 #endif
18160     if (!PyArg_ParseTuple(_args, "O&l",
18161                           CmpInstObj_Convert, &ci,
18162                           &index))
18163         return NULL;
18164     _rv = VDSetKeyColor(ci,
18165                         index);
18166     _res = Py_BuildValue("l",
18167                          _rv);
18168     return _res;
18169 }
18170
18171 static PyObject *Qt_VDGetKeyColor(PyObject *_self, PyObject *_args)
18172 {
18173     PyObject *_res = NULL;
18174     ComponentResult _rv;
18175     VideoDigitizerComponent ci;
18176     long index;
18177 #ifndef VDGetKeyColor
18178     PyMac_PRECHECK(VDGetKeyColor);
18179 #endif
18180     if (!PyArg_ParseTuple(_args, "O&",
18181                           CmpInstObj_Convert, &ci))
18182         return NULL;
18183     _rv = VDGetKeyColor(ci,
18184                         &index);
18185     _res = Py_BuildValue("ll",
18186                          _rv,
18187                          index);
18188     return _res;
18189 }
18190
18191 static PyObject *Qt_VDAddKeyColor(PyObject *_self, PyObject *_args)
18192 {
18193     PyObject *_res = NULL;
18194     ComponentResult _rv;
18195     VideoDigitizerComponent ci;
18196     long index;
18197 #ifndef VDAddKeyColor
18198     PyMac_PRECHECK(VDAddKeyColor);
18199 #endif
18200     if (!PyArg_ParseTuple(_args, "O&",
18201                           CmpInstObj_Convert, &ci))
18202         return NULL;
18203     _rv = VDAddKeyColor(ci,
18204                         &index);
18205     _res = Py_BuildValue("ll",
18206                          _rv,
18207                          index);
18208     return _res;
18209 }
18210
18211 static PyObject *Qt_VDGetNextKeyColor(PyObject *_self, PyObject *_args)
18212 {
18213     PyObject *_res = NULL;
18214     ComponentResult _rv;
18215     VideoDigitizerComponent ci;
18216     long index;
18217 #ifndef VDGetNextKeyColor
18218     PyMac_PRECHECK(VDGetNextKeyColor);
18219 #endif
18220     if (!PyArg_ParseTuple(_args, "O&l",
18221                           CmpInstObj_Convert, &ci,
18222                           &index))
18223         return NULL;
18224     _rv = VDGetNextKeyColor(ci,
18225                             index);
18226     _res = Py_BuildValue("l",
18227                          _rv);
18228     return _res;
18229 }
18230
18231 static PyObject *Qt_VDSetKeyColorRange(PyObject *_self, PyObject *_args)
18232 {
18233     PyObject *_res = NULL;
18234     ComponentResult _rv;
18235     VideoDigitizerComponent ci;
18236     RGBColor minRGB;
18237     RGBColor maxRGB;
18238 #ifndef VDSetKeyColorRange
18239     PyMac_PRECHECK(VDSetKeyColorRange);
18240 #endif
18241     if (!PyArg_ParseTuple(_args, "O&",
18242                           CmpInstObj_Convert, &ci))
18243         return NULL;
18244     _rv = VDSetKeyColorRange(ci,
18245                              &minRGB,
18246                              &maxRGB);
18247     _res = Py_BuildValue("lO&O&",
18248                          _rv,
18249                          QdRGB_New, &minRGB,
18250                          QdRGB_New, &maxRGB);
18251     return _res;
18252 }
18253
18254 static PyObject *Qt_VDGetKeyColorRange(PyObject *_self, PyObject *_args)
18255 {
18256     PyObject *_res = NULL;
18257     ComponentResult _rv;
18258     VideoDigitizerComponent ci;
18259     RGBColor minRGB;
18260     RGBColor maxRGB;
18261 #ifndef VDGetKeyColorRange
18262     PyMac_PRECHECK(VDGetKeyColorRange);
18263 #endif
18264     if (!PyArg_ParseTuple(_args, "O&",
18265                           CmpInstObj_Convert, &ci))
18266         return NULL;
18267     _rv = VDGetKeyColorRange(ci,
18268                              &minRGB,
18269                              &maxRGB);
18270     _res = Py_BuildValue("lO&O&",
18271                          _rv,
18272                          QdRGB_New, &minRGB,
18273                          QdRGB_New, &maxRGB);
18274     return _res;
18275 }
18276
18277 static PyObject *Qt_VDSetInputColorSpaceMode(PyObject *_self, PyObject *_args)
18278 {
18279     PyObject *_res = NULL;
18280     ComponentResult _rv;
18281     VideoDigitizerComponent ci;
18282     short colorSpaceMode;
18283 #ifndef VDSetInputColorSpaceMode
18284     PyMac_PRECHECK(VDSetInputColorSpaceMode);
18285 #endif
18286     if (!PyArg_ParseTuple(_args, "O&h",
18287                           CmpInstObj_Convert, &ci,
18288                           &colorSpaceMode))
18289         return NULL;
18290     _rv = VDSetInputColorSpaceMode(ci,
18291                                    colorSpaceMode);
18292     _res = Py_BuildValue("l",
18293                          _rv);
18294     return _res;
18295 }
18296
18297 static PyObject *Qt_VDGetInputColorSpaceMode(PyObject *_self, PyObject *_args)
18298 {
18299     PyObject *_res = NULL;
18300     ComponentResult _rv;
18301     VideoDigitizerComponent ci;
18302     short colorSpaceMode;
18303 #ifndef VDGetInputColorSpaceMode
18304     PyMac_PRECHECK(VDGetInputColorSpaceMode);
18305 #endif
18306     if (!PyArg_ParseTuple(_args, "O&",
18307                           CmpInstObj_Convert, &ci))
18308         return NULL;
18309     _rv = VDGetInputColorSpaceMode(ci,
18310                                    &colorSpaceMode);
18311     _res = Py_BuildValue("lh",
18312                          _rv,
18313                          colorSpaceMode);
18314     return _res;
18315 }
18316
18317 static PyObject *Qt_VDSetClipState(PyObject *_self, PyObject *_args)
18318 {
18319     PyObject *_res = NULL;
18320     ComponentResult _rv;
18321     VideoDigitizerComponent ci;
18322     short clipEnable;
18323 #ifndef VDSetClipState
18324     PyMac_PRECHECK(VDSetClipState);
18325 #endif
18326     if (!PyArg_ParseTuple(_args, "O&h",
18327                           CmpInstObj_Convert, &ci,
18328                           &clipEnable))
18329         return NULL;
18330     _rv = VDSetClipState(ci,
18331                          clipEnable);
18332     _res = Py_BuildValue("l",
18333                          _rv);
18334     return _res;
18335 }
18336
18337 static PyObject *Qt_VDGetClipState(PyObject *_self, PyObject *_args)
18338 {
18339     PyObject *_res = NULL;
18340     ComponentResult _rv;
18341     VideoDigitizerComponent ci;
18342     short clipEnable;
18343 #ifndef VDGetClipState
18344     PyMac_PRECHECK(VDGetClipState);
18345 #endif
18346     if (!PyArg_ParseTuple(_args, "O&",
18347                           CmpInstObj_Convert, &ci))
18348         return NULL;
18349     _rv = VDGetClipState(ci,
18350                          &clipEnable);
18351     _res = Py_BuildValue("lh",
18352                          _rv,
18353                          clipEnable);
18354     return _res;
18355 }
18356
18357 static PyObject *Qt_VDSetClipRgn(PyObject *_self, PyObject *_args)
18358 {
18359     PyObject *_res = NULL;
18360     ComponentResult _rv;
18361     VideoDigitizerComponent ci;
18362     RgnHandle clipRegion;
18363 #ifndef VDSetClipRgn
18364     PyMac_PRECHECK(VDSetClipRgn);
18365 #endif
18366     if (!PyArg_ParseTuple(_args, "O&O&",
18367                           CmpInstObj_Convert, &ci,
18368                           ResObj_Convert, &clipRegion))
18369         return NULL;
18370     _rv = VDSetClipRgn(ci,
18371                        clipRegion);
18372     _res = Py_BuildValue("l",
18373                          _rv);
18374     return _res;
18375 }
18376
18377 static PyObject *Qt_VDClearClipRgn(PyObject *_self, PyObject *_args)
18378 {
18379     PyObject *_res = NULL;
18380     ComponentResult _rv;
18381     VideoDigitizerComponent ci;
18382     RgnHandle clipRegion;
18383 #ifndef VDClearClipRgn
18384     PyMac_PRECHECK(VDClearClipRgn);
18385 #endif
18386     if (!PyArg_ParseTuple(_args, "O&O&",
18387                           CmpInstObj_Convert, &ci,
18388                           ResObj_Convert, &clipRegion))
18389         return NULL;
18390     _rv = VDClearClipRgn(ci,
18391                          clipRegion);
18392     _res = Py_BuildValue("l",
18393                          _rv);
18394     return _res;
18395 }
18396
18397 static PyObject *Qt_VDGetCLUTInUse(PyObject *_self, PyObject *_args)
18398 {
18399     PyObject *_res = NULL;
18400     ComponentResult _rv;
18401     VideoDigitizerComponent ci;
18402     CTabHandle colorTableHandle;
18403 #ifndef VDGetCLUTInUse
18404     PyMac_PRECHECK(VDGetCLUTInUse);
18405 #endif
18406     if (!PyArg_ParseTuple(_args, "O&",
18407                           CmpInstObj_Convert, &ci))
18408         return NULL;
18409     _rv = VDGetCLUTInUse(ci,
18410                          &colorTableHandle);
18411     _res = Py_BuildValue("lO&",
18412                          _rv,
18413                          ResObj_New, colorTableHandle);
18414     return _res;
18415 }
18416
18417 static PyObject *Qt_VDSetPLLFilterType(PyObject *_self, PyObject *_args)
18418 {
18419     PyObject *_res = NULL;
18420     ComponentResult _rv;
18421     VideoDigitizerComponent ci;
18422     short pllType;
18423 #ifndef VDSetPLLFilterType
18424     PyMac_PRECHECK(VDSetPLLFilterType);
18425 #endif
18426     if (!PyArg_ParseTuple(_args, "O&h",
18427                           CmpInstObj_Convert, &ci,
18428                           &pllType))
18429         return NULL;
18430     _rv = VDSetPLLFilterType(ci,
18431                              pllType);
18432     _res = Py_BuildValue("l",
18433                          _rv);
18434     return _res;
18435 }
18436
18437 static PyObject *Qt_VDGetPLLFilterType(PyObject *_self, PyObject *_args)
18438 {
18439     PyObject *_res = NULL;
18440     ComponentResult _rv;
18441     VideoDigitizerComponent ci;
18442     short pllType;
18443 #ifndef VDGetPLLFilterType
18444     PyMac_PRECHECK(VDGetPLLFilterType);
18445 #endif
18446     if (!PyArg_ParseTuple(_args, "O&",
18447                           CmpInstObj_Convert, &ci))
18448         return NULL;
18449     _rv = VDGetPLLFilterType(ci,
18450                              &pllType);
18451     _res = Py_BuildValue("lh",
18452                          _rv,
18453                          pllType);
18454     return _res;
18455 }
18456
18457 static PyObject *Qt_VDGetMaskandValue(PyObject *_self, PyObject *_args)
18458 {
18459     PyObject *_res = NULL;
18460     ComponentResult _rv;
18461     VideoDigitizerComponent ci;
18462     unsigned short blendLevel;
18463     long mask;
18464     long value;
18465 #ifndef VDGetMaskandValue
18466     PyMac_PRECHECK(VDGetMaskandValue);
18467 #endif
18468     if (!PyArg_ParseTuple(_args, "O&H",
18469                           CmpInstObj_Convert, &ci,
18470                           &blendLevel))
18471         return NULL;
18472     _rv = VDGetMaskandValue(ci,
18473                             blendLevel,
18474                             &mask,
18475                             &value);
18476     _res = Py_BuildValue("lll",
18477                          _rv,
18478                          mask,
18479                          value);
18480     return _res;
18481 }
18482
18483 static PyObject *Qt_VDSetMasterBlendLevel(PyObject *_self, PyObject *_args)
18484 {
18485     PyObject *_res = NULL;
18486     ComponentResult _rv;
18487     VideoDigitizerComponent ci;
18488     unsigned short blendLevel;
18489 #ifndef VDSetMasterBlendLevel
18490     PyMac_PRECHECK(VDSetMasterBlendLevel);
18491 #endif
18492     if (!PyArg_ParseTuple(_args, "O&",
18493                           CmpInstObj_Convert, &ci))
18494         return NULL;
18495     _rv = VDSetMasterBlendLevel(ci,
18496                                 &blendLevel);
18497     _res = Py_BuildValue("lH",
18498                          _rv,
18499                          blendLevel);
18500     return _res;
18501 }
18502
18503 static PyObject *Qt_VDSetPlayThruOnOff(PyObject *_self, PyObject *_args)
18504 {
18505     PyObject *_res = NULL;
18506     ComponentResult _rv;
18507     VideoDigitizerComponent ci;
18508     short state;
18509 #ifndef VDSetPlayThruOnOff
18510     PyMac_PRECHECK(VDSetPlayThruOnOff);
18511 #endif
18512     if (!PyArg_ParseTuple(_args, "O&h",
18513                           CmpInstObj_Convert, &ci,
18514                           &state))
18515         return NULL;
18516     _rv = VDSetPlayThruOnOff(ci,
18517                              state);
18518     _res = Py_BuildValue("l",
18519                          _rv);
18520     return _res;
18521 }
18522
18523 static PyObject *Qt_VDSetFieldPreference(PyObject *_self, PyObject *_args)
18524 {
18525     PyObject *_res = NULL;
18526     ComponentResult _rv;
18527     VideoDigitizerComponent ci;
18528     short fieldFlag;
18529 #ifndef VDSetFieldPreference
18530     PyMac_PRECHECK(VDSetFieldPreference);
18531 #endif
18532     if (!PyArg_ParseTuple(_args, "O&h",
18533                           CmpInstObj_Convert, &ci,
18534                           &fieldFlag))
18535         return NULL;
18536     _rv = VDSetFieldPreference(ci,
18537                                fieldFlag);
18538     _res = Py_BuildValue("l",
18539                          _rv);
18540     return _res;
18541 }
18542
18543 static PyObject *Qt_VDGetFieldPreference(PyObject *_self, PyObject *_args)
18544 {
18545     PyObject *_res = NULL;
18546     ComponentResult _rv;
18547     VideoDigitizerComponent ci;
18548     short fieldFlag;
18549 #ifndef VDGetFieldPreference
18550     PyMac_PRECHECK(VDGetFieldPreference);
18551 #endif
18552     if (!PyArg_ParseTuple(_args, "O&",
18553                           CmpInstObj_Convert, &ci))
18554         return NULL;
18555     _rv = VDGetFieldPreference(ci,
18556                                &fieldFlag);
18557     _res = Py_BuildValue("lh",
18558                          _rv,
18559                          fieldFlag);
18560     return _res;
18561 }
18562
18563 static PyObject *Qt_VDPreflightGlobalRect(PyObject *_self, PyObject *_args)
18564 {
18565     PyObject *_res = NULL;
18566     ComponentResult _rv;
18567     VideoDigitizerComponent ci;
18568     GrafPtr theWindow;
18569     Rect globalRect;
18570 #ifndef VDPreflightGlobalRect
18571     PyMac_PRECHECK(VDPreflightGlobalRect);
18572 #endif
18573     if (!PyArg_ParseTuple(_args, "O&O&",
18574                           CmpInstObj_Convert, &ci,
18575                           GrafObj_Convert, &theWindow))
18576         return NULL;
18577     _rv = VDPreflightGlobalRect(ci,
18578                                 theWindow,
18579                                 &globalRect);
18580     _res = Py_BuildValue("lO&",
18581                          _rv,
18582                          PyMac_BuildRect, &globalRect);
18583     return _res;
18584 }
18585
18586 static PyObject *Qt_VDSetPlayThruGlobalRect(PyObject *_self, PyObject *_args)
18587 {
18588     PyObject *_res = NULL;
18589     ComponentResult _rv;
18590     VideoDigitizerComponent ci;
18591     GrafPtr theWindow;
18592     Rect globalRect;
18593 #ifndef VDSetPlayThruGlobalRect
18594     PyMac_PRECHECK(VDSetPlayThruGlobalRect);
18595 #endif
18596     if (!PyArg_ParseTuple(_args, "O&O&",
18597                           CmpInstObj_Convert, &ci,
18598                           GrafObj_Convert, &theWindow))
18599         return NULL;
18600     _rv = VDSetPlayThruGlobalRect(ci,
18601                                   theWindow,
18602                                   &globalRect);
18603     _res = Py_BuildValue("lO&",
18604                          _rv,
18605                          PyMac_BuildRect, &globalRect);
18606     return _res;
18607 }
18608
18609 static PyObject *Qt_VDSetBlackLevelValue(PyObject *_self, PyObject *_args)
18610 {
18611     PyObject *_res = NULL;
18612     ComponentResult _rv;
18613     VideoDigitizerComponent ci;
18614     unsigned short blackLevel;
18615 #ifndef VDSetBlackLevelValue
18616     PyMac_PRECHECK(VDSetBlackLevelValue);
18617 #endif
18618     if (!PyArg_ParseTuple(_args, "O&",
18619                           CmpInstObj_Convert, &ci))
18620         return NULL;
18621     _rv = VDSetBlackLevelValue(ci,
18622                                &blackLevel);
18623     _res = Py_BuildValue("lH",
18624                          _rv,
18625                          blackLevel);
18626     return _res;
18627 }
18628
18629 static PyObject *Qt_VDGetBlackLevelValue(PyObject *_self, PyObject *_args)
18630 {
18631     PyObject *_res = NULL;
18632     ComponentResult _rv;
18633     VideoDigitizerComponent ci;
18634     unsigned short blackLevel;
18635 #ifndef VDGetBlackLevelValue
18636     PyMac_PRECHECK(VDGetBlackLevelValue);
18637 #endif
18638     if (!PyArg_ParseTuple(_args, "O&",
18639                           CmpInstObj_Convert, &ci))
18640         return NULL;
18641     _rv = VDGetBlackLevelValue(ci,
18642                                &blackLevel);
18643     _res = Py_BuildValue("lH",
18644                          _rv,
18645                          blackLevel);
18646     return _res;
18647 }
18648
18649 static PyObject *Qt_VDSetWhiteLevelValue(PyObject *_self, PyObject *_args)
18650 {
18651     PyObject *_res = NULL;
18652     ComponentResult _rv;
18653     VideoDigitizerComponent ci;
18654     unsigned short whiteLevel;
18655 #ifndef VDSetWhiteLevelValue
18656     PyMac_PRECHECK(VDSetWhiteLevelValue);
18657 #endif
18658     if (!PyArg_ParseTuple(_args, "O&",
18659                           CmpInstObj_Convert, &ci))
18660         return NULL;
18661     _rv = VDSetWhiteLevelValue(ci,
18662                                &whiteLevel);
18663     _res = Py_BuildValue("lH",
18664                          _rv,
18665                          whiteLevel);
18666     return _res;
18667 }
18668
18669 static PyObject *Qt_VDGetWhiteLevelValue(PyObject *_self, PyObject *_args)
18670 {
18671     PyObject *_res = NULL;
18672     ComponentResult _rv;
18673     VideoDigitizerComponent ci;
18674     unsigned short whiteLevel;
18675 #ifndef VDGetWhiteLevelValue
18676     PyMac_PRECHECK(VDGetWhiteLevelValue);
18677 #endif
18678     if (!PyArg_ParseTuple(_args, "O&",
18679                           CmpInstObj_Convert, &ci))
18680         return NULL;
18681     _rv = VDGetWhiteLevelValue(ci,
18682                                &whiteLevel);
18683     _res = Py_BuildValue("lH",
18684                          _rv,
18685                          whiteLevel);
18686     return _res;
18687 }
18688
18689 static PyObject *Qt_VDGetVideoDefaults(PyObject *_self, PyObject *_args)
18690 {
18691     PyObject *_res = NULL;
18692     ComponentResult _rv;
18693     VideoDigitizerComponent ci;
18694     unsigned short blackLevel;
18695     unsigned short whiteLevel;
18696     unsigned short brightness;
18697     unsigned short hue;
18698     unsigned short saturation;
18699     unsigned short contrast;
18700     unsigned short sharpness;
18701 #ifndef VDGetVideoDefaults
18702     PyMac_PRECHECK(VDGetVideoDefaults);
18703 #endif
18704     if (!PyArg_ParseTuple(_args, "O&",
18705                           CmpInstObj_Convert, &ci))
18706         return NULL;
18707     _rv = VDGetVideoDefaults(ci,
18708                              &blackLevel,
18709                              &whiteLevel,
18710                              &brightness,
18711                              &hue,
18712                              &saturation,
18713                              &contrast,
18714                              &sharpness);
18715     _res = Py_BuildValue("lHHHHHHH",
18716                          _rv,
18717                          blackLevel,
18718                          whiteLevel,
18719                          brightness,
18720                          hue,
18721                          saturation,
18722                          contrast,
18723                          sharpness);
18724     return _res;
18725 }
18726
18727 static PyObject *Qt_VDGetNumberOfInputs(PyObject *_self, PyObject *_args)
18728 {
18729     PyObject *_res = NULL;
18730     ComponentResult _rv;
18731     VideoDigitizerComponent ci;
18732     short inputs;
18733 #ifndef VDGetNumberOfInputs
18734     PyMac_PRECHECK(VDGetNumberOfInputs);
18735 #endif
18736     if (!PyArg_ParseTuple(_args, "O&",
18737                           CmpInstObj_Convert, &ci))
18738         return NULL;
18739     _rv = VDGetNumberOfInputs(ci,
18740                               &inputs);
18741     _res = Py_BuildValue("lh",
18742                          _rv,
18743                          inputs);
18744     return _res;
18745 }
18746
18747 static PyObject *Qt_VDGetInputFormat(PyObject *_self, PyObject *_args)
18748 {
18749     PyObject *_res = NULL;
18750     ComponentResult _rv;
18751     VideoDigitizerComponent ci;
18752     short input;
18753     short format;
18754 #ifndef VDGetInputFormat
18755     PyMac_PRECHECK(VDGetInputFormat);
18756 #endif
18757     if (!PyArg_ParseTuple(_args, "O&h",
18758                           CmpInstObj_Convert, &ci,
18759                           &input))
18760         return NULL;
18761     _rv = VDGetInputFormat(ci,
18762                            input,
18763                            &format);
18764     _res = Py_BuildValue("lh",
18765                          _rv,
18766                          format);
18767     return _res;
18768 }
18769
18770 static PyObject *Qt_VDSetInput(PyObject *_self, PyObject *_args)
18771 {
18772     PyObject *_res = NULL;
18773     ComponentResult _rv;
18774     VideoDigitizerComponent ci;
18775     short input;
18776 #ifndef VDSetInput
18777     PyMac_PRECHECK(VDSetInput);
18778 #endif
18779     if (!PyArg_ParseTuple(_args, "O&h",
18780                           CmpInstObj_Convert, &ci,
18781                           &input))
18782         return NULL;
18783     _rv = VDSetInput(ci,
18784                      input);
18785     _res = Py_BuildValue("l",
18786                          _rv);
18787     return _res;
18788 }
18789
18790 static PyObject *Qt_VDGetInput(PyObject *_self, PyObject *_args)
18791 {
18792     PyObject *_res = NULL;
18793     ComponentResult _rv;
18794     VideoDigitizerComponent ci;
18795     short input;
18796 #ifndef VDGetInput
18797     PyMac_PRECHECK(VDGetInput);
18798 #endif
18799     if (!PyArg_ParseTuple(_args, "O&",
18800                           CmpInstObj_Convert, &ci))
18801         return NULL;
18802     _rv = VDGetInput(ci,
18803                      &input);
18804     _res = Py_BuildValue("lh",
18805                          _rv,
18806                          input);
18807     return _res;
18808 }
18809
18810 static PyObject *Qt_VDSetInputStandard(PyObject *_self, PyObject *_args)
18811 {
18812     PyObject *_res = NULL;
18813     ComponentResult _rv;
18814     VideoDigitizerComponent ci;
18815     short inputStandard;
18816 #ifndef VDSetInputStandard
18817     PyMac_PRECHECK(VDSetInputStandard);
18818 #endif
18819     if (!PyArg_ParseTuple(_args, "O&h",
18820                           CmpInstObj_Convert, &ci,
18821                           &inputStandard))
18822         return NULL;
18823     _rv = VDSetInputStandard(ci,
18824                              inputStandard);
18825     _res = Py_BuildValue("l",
18826                          _rv);
18827     return _res;
18828 }
18829
18830 static PyObject *Qt_VDSetupBuffers(PyObject *_self, PyObject *_args)
18831 {
18832     PyObject *_res = NULL;
18833     ComponentResult _rv;
18834     VideoDigitizerComponent ci;
18835     VdigBufferRecListHandle bufferList;
18836 #ifndef VDSetupBuffers
18837     PyMac_PRECHECK(VDSetupBuffers);
18838 #endif
18839     if (!PyArg_ParseTuple(_args, "O&O&",
18840                           CmpInstObj_Convert, &ci,
18841                           ResObj_Convert, &bufferList))
18842         return NULL;
18843     _rv = VDSetupBuffers(ci,
18844                          bufferList);
18845     _res = Py_BuildValue("l",
18846                          _rv);
18847     return _res;
18848 }
18849
18850 static PyObject *Qt_VDGrabOneFrameAsync(PyObject *_self, PyObject *_args)
18851 {
18852     PyObject *_res = NULL;
18853     ComponentResult _rv;
18854     VideoDigitizerComponent ci;
18855     short buffer;
18856 #ifndef VDGrabOneFrameAsync
18857     PyMac_PRECHECK(VDGrabOneFrameAsync);
18858 #endif
18859     if (!PyArg_ParseTuple(_args, "O&h",
18860                           CmpInstObj_Convert, &ci,
18861                           &buffer))
18862         return NULL;
18863     _rv = VDGrabOneFrameAsync(ci,
18864                               buffer);
18865     _res = Py_BuildValue("l",
18866                          _rv);
18867     return _res;
18868 }
18869
18870 static PyObject *Qt_VDDone(PyObject *_self, PyObject *_args)
18871 {
18872     PyObject *_res = NULL;
18873     ComponentResult _rv;
18874     VideoDigitizerComponent ci;
18875     short buffer;
18876 #ifndef VDDone
18877     PyMac_PRECHECK(VDDone);
18878 #endif
18879     if (!PyArg_ParseTuple(_args, "O&h",
18880                           CmpInstObj_Convert, &ci,
18881                           &buffer))
18882         return NULL;
18883     _rv = VDDone(ci,
18884                  buffer);
18885     _res = Py_BuildValue("l",
18886                          _rv);
18887     return _res;
18888 }
18889
18890 static PyObject *Qt_VDSetCompression(PyObject *_self, PyObject *_args)
18891 {
18892     PyObject *_res = NULL;
18893     ComponentResult _rv;
18894     VideoDigitizerComponent ci;
18895     OSType compressType;
18896     short depth;
18897     Rect bounds;
18898     CodecQ spatialQuality;
18899     CodecQ temporalQuality;
18900     long keyFrameRate;
18901 #ifndef VDSetCompression
18902     PyMac_PRECHECK(VDSetCompression);
18903 #endif
18904     if (!PyArg_ParseTuple(_args, "O&O&hlll",
18905                           CmpInstObj_Convert, &ci,
18906                           PyMac_GetOSType, &compressType,
18907                           &depth,
18908                           &spatialQuality,
18909                           &temporalQuality,
18910                           &keyFrameRate))
18911         return NULL;
18912     _rv = VDSetCompression(ci,
18913                            compressType,
18914                            depth,
18915                            &bounds,
18916                            spatialQuality,
18917                            temporalQuality,
18918                            keyFrameRate);
18919     _res = Py_BuildValue("lO&",
18920                          _rv,
18921                          PyMac_BuildRect, &bounds);
18922     return _res;
18923 }
18924
18925 static PyObject *Qt_VDCompressOneFrameAsync(PyObject *_self, PyObject *_args)
18926 {
18927     PyObject *_res = NULL;
18928     ComponentResult _rv;
18929     VideoDigitizerComponent ci;
18930 #ifndef VDCompressOneFrameAsync
18931     PyMac_PRECHECK(VDCompressOneFrameAsync);
18932 #endif
18933     if (!PyArg_ParseTuple(_args, "O&",
18934                           CmpInstObj_Convert, &ci))
18935         return NULL;
18936     _rv = VDCompressOneFrameAsync(ci);
18937     _res = Py_BuildValue("l",
18938                          _rv);
18939     return _res;
18940 }
18941
18942 static PyObject *Qt_VDGetImageDescription(PyObject *_self, PyObject *_args)
18943 {
18944     PyObject *_res = NULL;
18945     ComponentResult _rv;
18946     VideoDigitizerComponent ci;
18947     ImageDescriptionHandle desc;
18948 #ifndef VDGetImageDescription
18949     PyMac_PRECHECK(VDGetImageDescription);
18950 #endif
18951     if (!PyArg_ParseTuple(_args, "O&O&",
18952                           CmpInstObj_Convert, &ci,
18953                           ResObj_Convert, &desc))
18954         return NULL;
18955     _rv = VDGetImageDescription(ci,
18956                                 desc);
18957     _res = Py_BuildValue("l",
18958                          _rv);
18959     return _res;
18960 }
18961
18962 static PyObject *Qt_VDResetCompressSequence(PyObject *_self, PyObject *_args)
18963 {
18964     PyObject *_res = NULL;
18965     ComponentResult _rv;
18966     VideoDigitizerComponent ci;
18967 #ifndef VDResetCompressSequence
18968     PyMac_PRECHECK(VDResetCompressSequence);
18969 #endif
18970     if (!PyArg_ParseTuple(_args, "O&",
18971                           CmpInstObj_Convert, &ci))
18972         return NULL;
18973     _rv = VDResetCompressSequence(ci);
18974     _res = Py_BuildValue("l",
18975                          _rv);
18976     return _res;
18977 }
18978
18979 static PyObject *Qt_VDSetCompressionOnOff(PyObject *_self, PyObject *_args)
18980 {
18981     PyObject *_res = NULL;
18982     ComponentResult _rv;
18983     VideoDigitizerComponent ci;
18984     Boolean state;
18985 #ifndef VDSetCompressionOnOff
18986     PyMac_PRECHECK(VDSetCompressionOnOff);
18987 #endif
18988     if (!PyArg_ParseTuple(_args, "O&b",
18989                           CmpInstObj_Convert, &ci,
18990                           &state))
18991         return NULL;
18992     _rv = VDSetCompressionOnOff(ci,
18993                                 state);
18994     _res = Py_BuildValue("l",
18995                          _rv);
18996     return _res;
18997 }
18998
18999 static PyObject *Qt_VDGetCompressionTypes(PyObject *_self, PyObject *_args)
19000 {
19001     PyObject *_res = NULL;
19002     ComponentResult _rv;
19003     VideoDigitizerComponent ci;
19004     VDCompressionListHandle h;
19005 #ifndef VDGetCompressionTypes
19006     PyMac_PRECHECK(VDGetCompressionTypes);
19007 #endif
19008     if (!PyArg_ParseTuple(_args, "O&O&",
19009                           CmpInstObj_Convert, &ci,
19010                           ResObj_Convert, &h))
19011         return NULL;
19012     _rv = VDGetCompressionTypes(ci,
19013                                 h);
19014     _res = Py_BuildValue("l",
19015                          _rv);
19016     return _res;
19017 }
19018
19019 static PyObject *Qt_VDSetTimeBase(PyObject *_self, PyObject *_args)
19020 {
19021     PyObject *_res = NULL;
19022     ComponentResult _rv;
19023     VideoDigitizerComponent ci;
19024     TimeBase t;
19025 #ifndef VDSetTimeBase
19026     PyMac_PRECHECK(VDSetTimeBase);
19027 #endif
19028     if (!PyArg_ParseTuple(_args, "O&O&",
19029                           CmpInstObj_Convert, &ci,
19030                           TimeBaseObj_Convert, &t))
19031         return NULL;
19032     _rv = VDSetTimeBase(ci,
19033                         t);
19034     _res = Py_BuildValue("l",
19035                          _rv);
19036     return _res;
19037 }
19038
19039 static PyObject *Qt_VDSetFrameRate(PyObject *_self, PyObject *_args)
19040 {
19041     PyObject *_res = NULL;
19042     ComponentResult _rv;
19043     VideoDigitizerComponent ci;
19044     Fixed framesPerSecond;
19045 #ifndef VDSetFrameRate
19046     PyMac_PRECHECK(VDSetFrameRate);
19047 #endif
19048     if (!PyArg_ParseTuple(_args, "O&O&",
19049                           CmpInstObj_Convert, &ci,
19050                           PyMac_GetFixed, &framesPerSecond))
19051         return NULL;
19052     _rv = VDSetFrameRate(ci,
19053                          framesPerSecond);
19054     _res = Py_BuildValue("l",
19055                          _rv);
19056     return _res;
19057 }
19058
19059 static PyObject *Qt_VDGetDataRate(PyObject *_self, PyObject *_args)
19060 {
19061     PyObject *_res = NULL;
19062     ComponentResult _rv;
19063     VideoDigitizerComponent ci;
19064     long milliSecPerFrame;
19065     Fixed framesPerSecond;
19066     long bytesPerSecond;
19067 #ifndef VDGetDataRate
19068     PyMac_PRECHECK(VDGetDataRate);
19069 #endif
19070     if (!PyArg_ParseTuple(_args, "O&",
19071                           CmpInstObj_Convert, &ci))
19072         return NULL;
19073     _rv = VDGetDataRate(ci,
19074                         &milliSecPerFrame,
19075                         &framesPerSecond,
19076                         &bytesPerSecond);
19077     _res = Py_BuildValue("llO&l",
19078                          _rv,
19079                          milliSecPerFrame,
19080                          PyMac_BuildFixed, framesPerSecond,
19081                          bytesPerSecond);
19082     return _res;
19083 }
19084
19085 static PyObject *Qt_VDGetSoundInputDriver(PyObject *_self, PyObject *_args)
19086 {
19087     PyObject *_res = NULL;
19088     ComponentResult _rv;
19089     VideoDigitizerComponent ci;
19090     Str255 soundDriverName;
19091 #ifndef VDGetSoundInputDriver
19092     PyMac_PRECHECK(VDGetSoundInputDriver);
19093 #endif
19094     if (!PyArg_ParseTuple(_args, "O&O&",
19095                           CmpInstObj_Convert, &ci,
19096                           PyMac_GetStr255, soundDriverName))
19097         return NULL;
19098     _rv = VDGetSoundInputDriver(ci,
19099                                 soundDriverName);
19100     _res = Py_BuildValue("l",
19101                          _rv);
19102     return _res;
19103 }
19104
19105 static PyObject *Qt_VDGetDMADepths(PyObject *_self, PyObject *_args)
19106 {
19107     PyObject *_res = NULL;
19108     ComponentResult _rv;
19109     VideoDigitizerComponent ci;
19110     long depthArray;
19111     long preferredDepth;
19112 #ifndef VDGetDMADepths
19113     PyMac_PRECHECK(VDGetDMADepths);
19114 #endif
19115     if (!PyArg_ParseTuple(_args, "O&",
19116                           CmpInstObj_Convert, &ci))
19117         return NULL;
19118     _rv = VDGetDMADepths(ci,
19119                          &depthArray,
19120                          &preferredDepth);
19121     _res = Py_BuildValue("lll",
19122                          _rv,
19123                          depthArray,
19124                          preferredDepth);
19125     return _res;
19126 }
19127
19128 static PyObject *Qt_VDGetPreferredTimeScale(PyObject *_self, PyObject *_args)
19129 {
19130     PyObject *_res = NULL;
19131     ComponentResult _rv;
19132     VideoDigitizerComponent ci;
19133     TimeScale preferred;
19134 #ifndef VDGetPreferredTimeScale
19135     PyMac_PRECHECK(VDGetPreferredTimeScale);
19136 #endif
19137     if (!PyArg_ParseTuple(_args, "O&",
19138                           CmpInstObj_Convert, &ci))
19139         return NULL;
19140     _rv = VDGetPreferredTimeScale(ci,
19141                                   &preferred);
19142     _res = Py_BuildValue("ll",
19143                          _rv,
19144                          preferred);
19145     return _res;
19146 }
19147
19148 static PyObject *Qt_VDReleaseAsyncBuffers(PyObject *_self, PyObject *_args)
19149 {
19150     PyObject *_res = NULL;
19151     ComponentResult _rv;
19152     VideoDigitizerComponent ci;
19153 #ifndef VDReleaseAsyncBuffers
19154     PyMac_PRECHECK(VDReleaseAsyncBuffers);
19155 #endif
19156     if (!PyArg_ParseTuple(_args, "O&",
19157                           CmpInstObj_Convert, &ci))
19158         return NULL;
19159     _rv = VDReleaseAsyncBuffers(ci);
19160     _res = Py_BuildValue("l",
19161                          _rv);
19162     return _res;
19163 }
19164
19165 static PyObject *Qt_VDSetDataRate(PyObject *_self, PyObject *_args)
19166 {
19167     PyObject *_res = NULL;
19168     ComponentResult _rv;
19169     VideoDigitizerComponent ci;
19170     long bytesPerSecond;
19171 #ifndef VDSetDataRate
19172     PyMac_PRECHECK(VDSetDataRate);
19173 #endif
19174     if (!PyArg_ParseTuple(_args, "O&l",
19175                           CmpInstObj_Convert, &ci,
19176                           &bytesPerSecond))
19177         return NULL;
19178     _rv = VDSetDataRate(ci,
19179                         bytesPerSecond);
19180     _res = Py_BuildValue("l",
19181                          _rv);
19182     return _res;
19183 }
19184
19185 static PyObject *Qt_VDGetTimeCode(PyObject *_self, PyObject *_args)
19186 {
19187     PyObject *_res = NULL;
19188     ComponentResult _rv;
19189     VideoDigitizerComponent ci;
19190     TimeRecord atTime;
19191     void * timeCodeFormat;
19192     void * timeCodeTime;
19193 #ifndef VDGetTimeCode
19194     PyMac_PRECHECK(VDGetTimeCode);
19195 #endif
19196     if (!PyArg_ParseTuple(_args, "O&ss",
19197                           CmpInstObj_Convert, &ci,
19198                           &timeCodeFormat,
19199                           &timeCodeTime))
19200         return NULL;
19201     _rv = VDGetTimeCode(ci,
19202                         &atTime,
19203                         timeCodeFormat,
19204                         timeCodeTime);
19205     _res = Py_BuildValue("lO&",
19206                          _rv,
19207                          QtTimeRecord_New, &atTime);
19208     return _res;
19209 }
19210
19211 static PyObject *Qt_VDUseSafeBuffers(PyObject *_self, PyObject *_args)
19212 {
19213     PyObject *_res = NULL;
19214     ComponentResult _rv;
19215     VideoDigitizerComponent ci;
19216     Boolean useSafeBuffers;
19217 #ifndef VDUseSafeBuffers
19218     PyMac_PRECHECK(VDUseSafeBuffers);
19219 #endif
19220     if (!PyArg_ParseTuple(_args, "O&b",
19221                           CmpInstObj_Convert, &ci,
19222                           &useSafeBuffers))
19223         return NULL;
19224     _rv = VDUseSafeBuffers(ci,
19225                            useSafeBuffers);
19226     _res = Py_BuildValue("l",
19227                          _rv);
19228     return _res;
19229 }
19230
19231 static PyObject *Qt_VDGetSoundInputSource(PyObject *_self, PyObject *_args)
19232 {
19233     PyObject *_res = NULL;
19234     ComponentResult _rv;
19235     VideoDigitizerComponent ci;
19236     long videoInput;
19237     long soundInput;
19238 #ifndef VDGetSoundInputSource
19239     PyMac_PRECHECK(VDGetSoundInputSource);
19240 #endif
19241     if (!PyArg_ParseTuple(_args, "O&l",
19242                           CmpInstObj_Convert, &ci,
19243                           &videoInput))
19244         return NULL;
19245     _rv = VDGetSoundInputSource(ci,
19246                                 videoInput,
19247                                 &soundInput);
19248     _res = Py_BuildValue("ll",
19249                          _rv,
19250                          soundInput);
19251     return _res;
19252 }
19253
19254 static PyObject *Qt_VDGetCompressionTime(PyObject *_self, PyObject *_args)
19255 {
19256     PyObject *_res = NULL;
19257     ComponentResult _rv;
19258     VideoDigitizerComponent ci;
19259     OSType compressionType;
19260     short depth;
19261     Rect srcRect;
19262     CodecQ spatialQuality;
19263     CodecQ temporalQuality;
19264     unsigned long compressTime;
19265 #ifndef VDGetCompressionTime
19266     PyMac_PRECHECK(VDGetCompressionTime);
19267 #endif
19268     if (!PyArg_ParseTuple(_args, "O&O&h",
19269                           CmpInstObj_Convert, &ci,
19270                           PyMac_GetOSType, &compressionType,
19271                           &depth))
19272         return NULL;
19273     _rv = VDGetCompressionTime(ci,
19274                                compressionType,
19275                                depth,
19276                                &srcRect,
19277                                &spatialQuality,
19278                                &temporalQuality,
19279                                &compressTime);
19280     _res = Py_BuildValue("lO&lll",
19281                          _rv,
19282                          PyMac_BuildRect, &srcRect,
19283                          spatialQuality,
19284                          temporalQuality,
19285                          compressTime);
19286     return _res;
19287 }
19288
19289 static PyObject *Qt_VDSetPreferredPacketSize(PyObject *_self, PyObject *_args)
19290 {
19291     PyObject *_res = NULL;
19292     ComponentResult _rv;
19293     VideoDigitizerComponent ci;
19294     long preferredPacketSizeInBytes;
19295 #ifndef VDSetPreferredPacketSize
19296     PyMac_PRECHECK(VDSetPreferredPacketSize);
19297 #endif
19298     if (!PyArg_ParseTuple(_args, "O&l",
19299                           CmpInstObj_Convert, &ci,
19300                           &preferredPacketSizeInBytes))
19301         return NULL;
19302     _rv = VDSetPreferredPacketSize(ci,
19303                                    preferredPacketSizeInBytes);
19304     _res = Py_BuildValue("l",
19305                          _rv);
19306     return _res;
19307 }
19308
19309 static PyObject *Qt_VDSetPreferredImageDimensions(PyObject *_self, PyObject *_args)
19310 {
19311     PyObject *_res = NULL;
19312     ComponentResult _rv;
19313     VideoDigitizerComponent ci;
19314     long width;
19315     long height;
19316 #ifndef VDSetPreferredImageDimensions
19317     PyMac_PRECHECK(VDSetPreferredImageDimensions);
19318 #endif
19319     if (!PyArg_ParseTuple(_args, "O&ll",
19320                           CmpInstObj_Convert, &ci,
19321                           &width,
19322                           &height))
19323         return NULL;
19324     _rv = VDSetPreferredImageDimensions(ci,
19325                                         width,
19326                                         height);
19327     _res = Py_BuildValue("l",
19328                          _rv);
19329     return _res;
19330 }
19331
19332 static PyObject *Qt_VDGetPreferredImageDimensions(PyObject *_self, PyObject *_args)
19333 {
19334     PyObject *_res = NULL;
19335     ComponentResult _rv;
19336     VideoDigitizerComponent ci;
19337     long width;
19338     long height;
19339 #ifndef VDGetPreferredImageDimensions
19340     PyMac_PRECHECK(VDGetPreferredImageDimensions);
19341 #endif
19342     if (!PyArg_ParseTuple(_args, "O&",
19343                           CmpInstObj_Convert, &ci))
19344         return NULL;
19345     _rv = VDGetPreferredImageDimensions(ci,
19346                                         &width,
19347                                         &height);
19348     _res = Py_BuildValue("lll",
19349                          _rv,
19350                          width,
19351                          height);
19352     return _res;
19353 }
19354
19355 static PyObject *Qt_VDGetInputName(PyObject *_self, PyObject *_args)
19356 {
19357     PyObject *_res = NULL;
19358     ComponentResult _rv;
19359     VideoDigitizerComponent ci;
19360     long videoInput;
19361     Str255 name;
19362 #ifndef VDGetInputName
19363     PyMac_PRECHECK(VDGetInputName);
19364 #endif
19365     if (!PyArg_ParseTuple(_args, "O&lO&",
19366                           CmpInstObj_Convert, &ci,
19367                           &videoInput,
19368                           PyMac_GetStr255, name))
19369         return NULL;
19370     _rv = VDGetInputName(ci,
19371                          videoInput,
19372                          name);
19373     _res = Py_BuildValue("l",
19374                          _rv);
19375     return _res;
19376 }
19377
19378 static PyObject *Qt_VDSetDestinationPort(PyObject *_self, PyObject *_args)
19379 {
19380     PyObject *_res = NULL;
19381     ComponentResult _rv;
19382     VideoDigitizerComponent ci;
19383     CGrafPtr destPort;
19384 #ifndef VDSetDestinationPort
19385     PyMac_PRECHECK(VDSetDestinationPort);
19386 #endif
19387     if (!PyArg_ParseTuple(_args, "O&O&",
19388                           CmpInstObj_Convert, &ci,
19389                           GrafObj_Convert, &destPort))
19390         return NULL;
19391     _rv = VDSetDestinationPort(ci,
19392                                destPort);
19393     _res = Py_BuildValue("l",
19394                          _rv);
19395     return _res;
19396 }
19397
19398 static PyObject *Qt_VDGetDeviceNameAndFlags(PyObject *_self, PyObject *_args)
19399 {
19400     PyObject *_res = NULL;
19401     ComponentResult _rv;
19402     VideoDigitizerComponent ci;
19403     Str255 outName;
19404     UInt32 outNameFlags;
19405 #ifndef VDGetDeviceNameAndFlags
19406     PyMac_PRECHECK(VDGetDeviceNameAndFlags);
19407 #endif
19408     if (!PyArg_ParseTuple(_args, "O&O&",
19409                           CmpInstObj_Convert, &ci,
19410                           PyMac_GetStr255, outName))
19411         return NULL;
19412     _rv = VDGetDeviceNameAndFlags(ci,
19413                                   outName,
19414                                   &outNameFlags);
19415     _res = Py_BuildValue("ll",
19416                          _rv,
19417                          outNameFlags);
19418     return _res;
19419 }
19420
19421 static PyObject *Qt_VDCaptureStateChanging(PyObject *_self, PyObject *_args)
19422 {
19423     PyObject *_res = NULL;
19424     ComponentResult _rv;
19425     VideoDigitizerComponent ci;
19426     UInt32 inStateFlags;
19427 #ifndef VDCaptureStateChanging
19428     PyMac_PRECHECK(VDCaptureStateChanging);
19429 #endif
19430     if (!PyArg_ParseTuple(_args, "O&l",
19431                           CmpInstObj_Convert, &ci,
19432                           &inStateFlags))
19433         return NULL;
19434     _rv = VDCaptureStateChanging(ci,
19435                                  inStateFlags);
19436     _res = Py_BuildValue("l",
19437                          _rv);
19438     return _res;
19439 }
19440
19441 static PyObject *Qt_XMLParseGetDetailedParseError(PyObject *_self, PyObject *_args)
19442 {
19443     PyObject *_res = NULL;
19444     ComponentResult _rv;
19445     ComponentInstance aParser;
19446     long errorLine;
19447     StringPtr errDesc;
19448 #ifndef XMLParseGetDetailedParseError
19449     PyMac_PRECHECK(XMLParseGetDetailedParseError);
19450 #endif
19451     if (!PyArg_ParseTuple(_args, "O&s",
19452                           CmpInstObj_Convert, &aParser,
19453                           &errDesc))
19454         return NULL;
19455     _rv = XMLParseGetDetailedParseError(aParser,
19456                                         &errorLine,
19457                                         errDesc);
19458     _res = Py_BuildValue("ll",
19459                          _rv,
19460                          errorLine);
19461     return _res;
19462 }
19463
19464 static PyObject *Qt_XMLParseAddElement(PyObject *_self, PyObject *_args)
19465 {
19466     PyObject *_res = NULL;
19467     ComponentResult _rv;
19468     ComponentInstance aParser;
19469     char elementName;
19470     UInt32 nameSpaceID;
19471     UInt32 elementID;
19472     long elementFlags;
19473 #ifndef XMLParseAddElement
19474     PyMac_PRECHECK(XMLParseAddElement);
19475 #endif
19476     if (!PyArg_ParseTuple(_args, "O&ll",
19477                           CmpInstObj_Convert, &aParser,
19478                           &nameSpaceID,
19479                           &elementFlags))
19480         return NULL;
19481     _rv = XMLParseAddElement(aParser,
19482                              &elementName,
19483                              nameSpaceID,
19484                              &elementID,
19485                              elementFlags);
19486     _res = Py_BuildValue("lcl",
19487                          _rv,
19488                          elementName,
19489                          elementID);
19490     return _res;
19491 }
19492
19493 static PyObject *Qt_XMLParseAddAttribute(PyObject *_self, PyObject *_args)
19494 {
19495     PyObject *_res = NULL;
19496     ComponentResult _rv;
19497     ComponentInstance aParser;
19498     UInt32 elementID;
19499     UInt32 nameSpaceID;
19500     char attributeName;
19501     UInt32 attributeID;
19502 #ifndef XMLParseAddAttribute
19503     PyMac_PRECHECK(XMLParseAddAttribute);
19504 #endif
19505     if (!PyArg_ParseTuple(_args, "O&ll",
19506                           CmpInstObj_Convert, &aParser,
19507                           &elementID,
19508                           &nameSpaceID))
19509         return NULL;
19510     _rv = XMLParseAddAttribute(aParser,
19511                                elementID,
19512                                nameSpaceID,
19513                                &attributeName,
19514                                &attributeID);
19515     _res = Py_BuildValue("lcl",
19516                          _rv,
19517                          attributeName,
19518                          attributeID);
19519     return _res;
19520 }
19521
19522 static PyObject *Qt_XMLParseAddMultipleAttributes(PyObject *_self, PyObject *_args)
19523 {
19524     PyObject *_res = NULL;
19525     ComponentResult _rv;
19526     ComponentInstance aParser;
19527     UInt32 elementID;
19528     UInt32 nameSpaceIDs;
19529     char attributeNames;
19530     UInt32 attributeIDs;
19531 #ifndef XMLParseAddMultipleAttributes
19532     PyMac_PRECHECK(XMLParseAddMultipleAttributes);
19533 #endif
19534     if (!PyArg_ParseTuple(_args, "O&l",
19535                           CmpInstObj_Convert, &aParser,
19536                           &elementID))
19537         return NULL;
19538     _rv = XMLParseAddMultipleAttributes(aParser,
19539                                         elementID,
19540                                         &nameSpaceIDs,
19541                                         &attributeNames,
19542                                         &attributeIDs);
19543     _res = Py_BuildValue("llcl",
19544                          _rv,
19545                          nameSpaceIDs,
19546                          attributeNames,
19547                          attributeIDs);
19548     return _res;
19549 }
19550
19551 static PyObject *Qt_XMLParseAddAttributeAndValue(PyObject *_self, PyObject *_args)
19552 {
19553     PyObject *_res = NULL;
19554     ComponentResult _rv;
19555     ComponentInstance aParser;
19556     UInt32 elementID;
19557     UInt32 nameSpaceID;
19558     char attributeName;
19559     UInt32 attributeID;
19560     UInt32 attributeValueKind;
19561     void * attributeValueKindInfo;
19562 #ifndef XMLParseAddAttributeAndValue
19563     PyMac_PRECHECK(XMLParseAddAttributeAndValue);
19564 #endif
19565     if (!PyArg_ParseTuple(_args, "O&llls",
19566                           CmpInstObj_Convert, &aParser,
19567                           &elementID,
19568                           &nameSpaceID,
19569                           &attributeValueKind,
19570                           &attributeValueKindInfo))
19571         return NULL;
19572     _rv = XMLParseAddAttributeAndValue(aParser,
19573                                        elementID,
19574                                        nameSpaceID,
19575                                        &attributeName,
19576                                        &attributeID,
19577                                        attributeValueKind,
19578                                        attributeValueKindInfo);
19579     _res = Py_BuildValue("lcl",
19580                          _rv,
19581                          attributeName,
19582                          attributeID);
19583     return _res;
19584 }
19585
19586 static PyObject *Qt_XMLParseAddAttributeValueKind(PyObject *_self, PyObject *_args)
19587 {
19588     PyObject *_res = NULL;
19589     ComponentResult _rv;
19590     ComponentInstance aParser;
19591     UInt32 elementID;
19592     UInt32 attributeID;
19593     UInt32 attributeValueKind;
19594     void * attributeValueKindInfo;
19595 #ifndef XMLParseAddAttributeValueKind
19596     PyMac_PRECHECK(XMLParseAddAttributeValueKind);
19597 #endif
19598     if (!PyArg_ParseTuple(_args, "O&llls",
19599                           CmpInstObj_Convert, &aParser,
19600                           &elementID,
19601                           &attributeID,
19602                           &attributeValueKind,
19603                           &attributeValueKindInfo))
19604         return NULL;
19605     _rv = XMLParseAddAttributeValueKind(aParser,
19606                                         elementID,
19607                                         attributeID,
19608                                         attributeValueKind,
19609                                         attributeValueKindInfo);
19610     _res = Py_BuildValue("l",
19611                          _rv);
19612     return _res;
19613 }
19614
19615 static PyObject *Qt_XMLParseAddNameSpace(PyObject *_self, PyObject *_args)
19616 {
19617     PyObject *_res = NULL;
19618     ComponentResult _rv;
19619     ComponentInstance aParser;
19620     char nameSpaceURL;
19621     UInt32 nameSpaceID;
19622 #ifndef XMLParseAddNameSpace
19623     PyMac_PRECHECK(XMLParseAddNameSpace);
19624 #endif
19625     if (!PyArg_ParseTuple(_args, "O&",
19626                           CmpInstObj_Convert, &aParser))
19627         return NULL;
19628     _rv = XMLParseAddNameSpace(aParser,
19629                                &nameSpaceURL,
19630                                &nameSpaceID);
19631     _res = Py_BuildValue("lcl",
19632                          _rv,
19633                          nameSpaceURL,
19634                          nameSpaceID);
19635     return _res;
19636 }
19637
19638 static PyObject *Qt_XMLParseSetOffsetAndLimit(PyObject *_self, PyObject *_args)
19639 {
19640     PyObject *_res = NULL;
19641     ComponentResult _rv;
19642     ComponentInstance aParser;
19643     UInt32 offset;
19644     UInt32 limit;
19645 #ifndef XMLParseSetOffsetAndLimit
19646     PyMac_PRECHECK(XMLParseSetOffsetAndLimit);
19647 #endif
19648     if (!PyArg_ParseTuple(_args, "O&ll",
19649                           CmpInstObj_Convert, &aParser,
19650                           &offset,
19651                           &limit))
19652         return NULL;
19653     _rv = XMLParseSetOffsetAndLimit(aParser,
19654                                     offset,
19655                                     limit);
19656     _res = Py_BuildValue("l",
19657                          _rv);
19658     return _res;
19659 }
19660
19661 static PyObject *Qt_XMLParseSetEventParseRefCon(PyObject *_self, PyObject *_args)
19662 {
19663     PyObject *_res = NULL;
19664     ComponentResult _rv;
19665     ComponentInstance aParser;
19666     long refcon;
19667 #ifndef XMLParseSetEventParseRefCon
19668     PyMac_PRECHECK(XMLParseSetEventParseRefCon);
19669 #endif
19670     if (!PyArg_ParseTuple(_args, "O&l",
19671                           CmpInstObj_Convert, &aParser,
19672                           &refcon))
19673         return NULL;
19674     _rv = XMLParseSetEventParseRefCon(aParser,
19675                                       refcon);
19676     _res = Py_BuildValue("l",
19677                          _rv);
19678     return _res;
19679 }
19680
19681 static PyObject *Qt_SGInitialize(PyObject *_self, PyObject *_args)
19682 {
19683     PyObject *_res = NULL;
19684     ComponentResult _rv;
19685     SeqGrabComponent s;
19686 #ifndef SGInitialize
19687     PyMac_PRECHECK(SGInitialize);
19688 #endif
19689     if (!PyArg_ParseTuple(_args, "O&",
19690                           CmpInstObj_Convert, &s))
19691         return NULL;
19692     _rv = SGInitialize(s);
19693     _res = Py_BuildValue("l",
19694                          _rv);
19695     return _res;
19696 }
19697
19698 static PyObject *Qt_SGSetDataOutput(PyObject *_self, PyObject *_args)
19699 {
19700     PyObject *_res = NULL;
19701     ComponentResult _rv;
19702     SeqGrabComponent s;
19703     FSSpec movieFile;
19704     long whereFlags;
19705 #ifndef SGSetDataOutput
19706     PyMac_PRECHECK(SGSetDataOutput);
19707 #endif
19708     if (!PyArg_ParseTuple(_args, "O&O&l",
19709                           CmpInstObj_Convert, &s,
19710                           PyMac_GetFSSpec, &movieFile,
19711                           &whereFlags))
19712         return NULL;
19713     _rv = SGSetDataOutput(s,
19714                           &movieFile,
19715                           whereFlags);
19716     _res = Py_BuildValue("l",
19717                          _rv);
19718     return _res;
19719 }
19720
19721 static PyObject *Qt_SGGetDataOutput(PyObject *_self, PyObject *_args)
19722 {
19723     PyObject *_res = NULL;
19724     ComponentResult _rv;
19725     SeqGrabComponent s;
19726     FSSpec movieFile;
19727     long whereFlags;
19728 #ifndef SGGetDataOutput
19729     PyMac_PRECHECK(SGGetDataOutput);
19730 #endif
19731     if (!PyArg_ParseTuple(_args, "O&O&",
19732                           CmpInstObj_Convert, &s,
19733                           PyMac_GetFSSpec, &movieFile))
19734         return NULL;
19735     _rv = SGGetDataOutput(s,
19736                           &movieFile,
19737                           &whereFlags);
19738     _res = Py_BuildValue("ll",
19739                          _rv,
19740                          whereFlags);
19741     return _res;
19742 }
19743
19744 static PyObject *Qt_SGSetGWorld(PyObject *_self, PyObject *_args)
19745 {
19746     PyObject *_res = NULL;
19747     ComponentResult _rv;
19748     SeqGrabComponent s;
19749     CGrafPtr gp;
19750     GDHandle gd;
19751 #ifndef SGSetGWorld
19752     PyMac_PRECHECK(SGSetGWorld);
19753 #endif
19754     if (!PyArg_ParseTuple(_args, "O&O&O&",
19755                           CmpInstObj_Convert, &s,
19756                           GrafObj_Convert, &gp,
19757                           OptResObj_Convert, &gd))
19758         return NULL;
19759     _rv = SGSetGWorld(s,
19760                       gp,
19761                       gd);
19762     _res = Py_BuildValue("l",
19763                          _rv);
19764     return _res;
19765 }
19766
19767 static PyObject *Qt_SGGetGWorld(PyObject *_self, PyObject *_args)
19768 {
19769     PyObject *_res = NULL;
19770     ComponentResult _rv;
19771     SeqGrabComponent s;
19772     CGrafPtr gp;
19773     GDHandle gd;
19774 #ifndef SGGetGWorld
19775     PyMac_PRECHECK(SGGetGWorld);
19776 #endif
19777     if (!PyArg_ParseTuple(_args, "O&",
19778                           CmpInstObj_Convert, &s))
19779         return NULL;
19780     _rv = SGGetGWorld(s,
19781                       &gp,
19782                       &gd);
19783     _res = Py_BuildValue("lO&O&",
19784                          _rv,
19785                          GrafObj_New, gp,
19786                          OptResObj_New, gd);
19787     return _res;
19788 }
19789
19790 static PyObject *Qt_SGNewChannel(PyObject *_self, PyObject *_args)
19791 {
19792     PyObject *_res = NULL;
19793     ComponentResult _rv;
19794     SeqGrabComponent s;
19795     OSType channelType;
19796     SGChannel ref;
19797 #ifndef SGNewChannel
19798     PyMac_PRECHECK(SGNewChannel);
19799 #endif
19800     if (!PyArg_ParseTuple(_args, "O&O&",
19801                           CmpInstObj_Convert, &s,
19802                           PyMac_GetOSType, &channelType))
19803         return NULL;
19804     _rv = SGNewChannel(s,
19805                        channelType,
19806                        &ref);
19807     _res = Py_BuildValue("lO&",
19808                          _rv,
19809                          CmpInstObj_New, ref);
19810     return _res;
19811 }
19812
19813 static PyObject *Qt_SGDisposeChannel(PyObject *_self, PyObject *_args)
19814 {
19815     PyObject *_res = NULL;
19816     ComponentResult _rv;
19817     SeqGrabComponent s;
19818     SGChannel c;
19819 #ifndef SGDisposeChannel
19820     PyMac_PRECHECK(SGDisposeChannel);
19821 #endif
19822     if (!PyArg_ParseTuple(_args, "O&O&",
19823                           CmpInstObj_Convert, &s,
19824                           CmpInstObj_Convert, &c))
19825         return NULL;
19826     _rv = SGDisposeChannel(s,
19827                            c);
19828     _res = Py_BuildValue("l",
19829                          _rv);
19830     return _res;
19831 }
19832
19833 static PyObject *Qt_SGStartPreview(PyObject *_self, PyObject *_args)
19834 {
19835     PyObject *_res = NULL;
19836     ComponentResult _rv;
19837     SeqGrabComponent s;
19838 #ifndef SGStartPreview
19839     PyMac_PRECHECK(SGStartPreview);
19840 #endif
19841     if (!PyArg_ParseTuple(_args, "O&",
19842                           CmpInstObj_Convert, &s))
19843         return NULL;
19844     _rv = SGStartPreview(s);
19845     _res = Py_BuildValue("l",
19846                          _rv);
19847     return _res;
19848 }
19849
19850 static PyObject *Qt_SGStartRecord(PyObject *_self, PyObject *_args)
19851 {
19852     PyObject *_res = NULL;
19853     ComponentResult _rv;
19854     SeqGrabComponent s;
19855 #ifndef SGStartRecord
19856     PyMac_PRECHECK(SGStartRecord);
19857 #endif
19858     if (!PyArg_ParseTuple(_args, "O&",
19859                           CmpInstObj_Convert, &s))
19860         return NULL;
19861     _rv = SGStartRecord(s);
19862     _res = Py_BuildValue("l",
19863                          _rv);
19864     return _res;
19865 }
19866
19867 static PyObject *Qt_SGIdle(PyObject *_self, PyObject *_args)
19868 {
19869     PyObject *_res = NULL;
19870     ComponentResult _rv;
19871     SeqGrabComponent s;
19872 #ifndef SGIdle
19873     PyMac_PRECHECK(SGIdle);
19874 #endif
19875     if (!PyArg_ParseTuple(_args, "O&",
19876                           CmpInstObj_Convert, &s))
19877         return NULL;
19878     _rv = SGIdle(s);
19879     _res = Py_BuildValue("l",
19880                          _rv);
19881     return _res;
19882 }
19883
19884 static PyObject *Qt_SGStop(PyObject *_self, PyObject *_args)
19885 {
19886     PyObject *_res = NULL;
19887     ComponentResult _rv;
19888     SeqGrabComponent s;
19889 #ifndef SGStop
19890     PyMac_PRECHECK(SGStop);
19891 #endif
19892     if (!PyArg_ParseTuple(_args, "O&",
19893                           CmpInstObj_Convert, &s))
19894         return NULL;
19895     _rv = SGStop(s);
19896     _res = Py_BuildValue("l",
19897                          _rv);
19898     return _res;
19899 }
19900
19901 static PyObject *Qt_SGPause(PyObject *_self, PyObject *_args)
19902 {
19903     PyObject *_res = NULL;
19904     ComponentResult _rv;
19905     SeqGrabComponent s;
19906     Boolean pause;
19907 #ifndef SGPause
19908     PyMac_PRECHECK(SGPause);
19909 #endif
19910     if (!PyArg_ParseTuple(_args, "O&b",
19911                           CmpInstObj_Convert, &s,
19912                           &pause))
19913         return NULL;
19914     _rv = SGPause(s,
19915                   pause);
19916     _res = Py_BuildValue("l",
19917                          _rv);
19918     return _res;
19919 }
19920
19921 static PyObject *Qt_SGPrepare(PyObject *_self, PyObject *_args)
19922 {
19923     PyObject *_res = NULL;
19924     ComponentResult _rv;
19925     SeqGrabComponent s;
19926     Boolean prepareForPreview;
19927     Boolean prepareForRecord;
19928 #ifndef SGPrepare
19929     PyMac_PRECHECK(SGPrepare);
19930 #endif
19931     if (!PyArg_ParseTuple(_args, "O&bb",
19932                           CmpInstObj_Convert, &s,
19933                           &prepareForPreview,
19934                           &prepareForRecord))
19935         return NULL;
19936     _rv = SGPrepare(s,
19937                     prepareForPreview,
19938                     prepareForRecord);
19939     _res = Py_BuildValue("l",
19940                          _rv);
19941     return _res;
19942 }
19943
19944 static PyObject *Qt_SGRelease(PyObject *_self, PyObject *_args)
19945 {
19946     PyObject *_res = NULL;
19947     ComponentResult _rv;
19948     SeqGrabComponent s;
19949 #ifndef SGRelease
19950     PyMac_PRECHECK(SGRelease);
19951 #endif
19952     if (!PyArg_ParseTuple(_args, "O&",
19953                           CmpInstObj_Convert, &s))
19954         return NULL;
19955     _rv = SGRelease(s);
19956     _res = Py_BuildValue("l",
19957                          _rv);
19958     return _res;
19959 }
19960
19961 static PyObject *Qt_SGGetMovie(PyObject *_self, PyObject *_args)
19962 {
19963     PyObject *_res = NULL;
19964     Movie _rv;
19965     SeqGrabComponent s;
19966 #ifndef SGGetMovie
19967     PyMac_PRECHECK(SGGetMovie);
19968 #endif
19969     if (!PyArg_ParseTuple(_args, "O&",
19970                           CmpInstObj_Convert, &s))
19971         return NULL;
19972     _rv = SGGetMovie(s);
19973     _res = Py_BuildValue("O&",
19974                          MovieObj_New, _rv);
19975     return _res;
19976 }
19977
19978 static PyObject *Qt_SGSetMaximumRecordTime(PyObject *_self, PyObject *_args)
19979 {
19980     PyObject *_res = NULL;
19981     ComponentResult _rv;
19982     SeqGrabComponent s;
19983     unsigned long ticks;
19984 #ifndef SGSetMaximumRecordTime
19985     PyMac_PRECHECK(SGSetMaximumRecordTime);
19986 #endif
19987     if (!PyArg_ParseTuple(_args, "O&l",
19988                           CmpInstObj_Convert, &s,
19989                           &ticks))
19990         return NULL;
19991     _rv = SGSetMaximumRecordTime(s,
19992                                  ticks);
19993     _res = Py_BuildValue("l",
19994                          _rv);
19995     return _res;
19996 }
19997
19998 static PyObject *Qt_SGGetMaximumRecordTime(PyObject *_self, PyObject *_args)
19999 {
20000     PyObject *_res = NULL;
20001     ComponentResult _rv;
20002     SeqGrabComponent s;
20003     unsigned long ticks;
20004 #ifndef SGGetMaximumRecordTime
20005     PyMac_PRECHECK(SGGetMaximumRecordTime);
20006 #endif
20007     if (!PyArg_ParseTuple(_args, "O&",
20008                           CmpInstObj_Convert, &s))
20009         return NULL;
20010     _rv = SGGetMaximumRecordTime(s,
20011                                  &ticks);
20012     _res = Py_BuildValue("ll",
20013                          _rv,
20014                          ticks);
20015     return _res;
20016 }
20017
20018 static PyObject *Qt_SGGetStorageSpaceRemaining(PyObject *_self, PyObject *_args)
20019 {
20020     PyObject *_res = NULL;
20021     ComponentResult _rv;
20022     SeqGrabComponent s;
20023     unsigned long bytes;
20024 #ifndef SGGetStorageSpaceRemaining
20025     PyMac_PRECHECK(SGGetStorageSpaceRemaining);
20026 #endif
20027     if (!PyArg_ParseTuple(_args, "O&",
20028                           CmpInstObj_Convert, &s))
20029         return NULL;
20030     _rv = SGGetStorageSpaceRemaining(s,
20031                                      &bytes);
20032     _res = Py_BuildValue("ll",
20033                          _rv,
20034                          bytes);
20035     return _res;
20036 }
20037
20038 static PyObject *Qt_SGGetTimeRemaining(PyObject *_self, PyObject *_args)
20039 {
20040     PyObject *_res = NULL;
20041     ComponentResult _rv;
20042     SeqGrabComponent s;
20043     long ticksLeft;
20044 #ifndef SGGetTimeRemaining
20045     PyMac_PRECHECK(SGGetTimeRemaining);
20046 #endif
20047     if (!PyArg_ParseTuple(_args, "O&",
20048                           CmpInstObj_Convert, &s))
20049         return NULL;
20050     _rv = SGGetTimeRemaining(s,
20051                              &ticksLeft);
20052     _res = Py_BuildValue("ll",
20053                          _rv,
20054                          ticksLeft);
20055     return _res;
20056 }
20057
20058 static PyObject *Qt_SGGrabPict(PyObject *_self, PyObject *_args)
20059 {
20060     PyObject *_res = NULL;
20061     ComponentResult _rv;
20062     SeqGrabComponent s;
20063     PicHandle p;
20064     Rect bounds;
20065     short offscreenDepth;
20066     long grabPictFlags;
20067 #ifndef SGGrabPict
20068     PyMac_PRECHECK(SGGrabPict);
20069 #endif
20070     if (!PyArg_ParseTuple(_args, "O&O&hl",
20071                           CmpInstObj_Convert, &s,
20072                           PyMac_GetRect, &bounds,
20073                           &offscreenDepth,
20074                           &grabPictFlags))
20075         return NULL;
20076     _rv = SGGrabPict(s,
20077                      &p,
20078                      &bounds,
20079                      offscreenDepth,
20080                      grabPictFlags);
20081     _res = Py_BuildValue("lO&",
20082                          _rv,
20083                          ResObj_New, p);
20084     return _res;
20085 }
20086
20087 static PyObject *Qt_SGGetLastMovieResID(PyObject *_self, PyObject *_args)
20088 {
20089     PyObject *_res = NULL;
20090     ComponentResult _rv;
20091     SeqGrabComponent s;
20092     short resID;
20093 #ifndef SGGetLastMovieResID
20094     PyMac_PRECHECK(SGGetLastMovieResID);
20095 #endif
20096     if (!PyArg_ParseTuple(_args, "O&",
20097                           CmpInstObj_Convert, &s))
20098         return NULL;
20099     _rv = SGGetLastMovieResID(s,
20100                               &resID);
20101     _res = Py_BuildValue("lh",
20102                          _rv,
20103                          resID);
20104     return _res;
20105 }
20106
20107 static PyObject *Qt_SGSetFlags(PyObject *_self, PyObject *_args)
20108 {
20109     PyObject *_res = NULL;
20110     ComponentResult _rv;
20111     SeqGrabComponent s;
20112     long sgFlags;
20113 #ifndef SGSetFlags
20114     PyMac_PRECHECK(SGSetFlags);
20115 #endif
20116     if (!PyArg_ParseTuple(_args, "O&l",
20117                           CmpInstObj_Convert, &s,
20118                           &sgFlags))
20119         return NULL;
20120     _rv = SGSetFlags(s,
20121                      sgFlags);
20122     _res = Py_BuildValue("l",
20123                          _rv);
20124     return _res;
20125 }
20126
20127 static PyObject *Qt_SGGetFlags(PyObject *_self, PyObject *_args)
20128 {
20129     PyObject *_res = NULL;
20130     ComponentResult _rv;
20131     SeqGrabComponent s;
20132     long sgFlags;
20133 #ifndef SGGetFlags
20134     PyMac_PRECHECK(SGGetFlags);
20135 #endif
20136     if (!PyArg_ParseTuple(_args, "O&",
20137                           CmpInstObj_Convert, &s))
20138         return NULL;
20139     _rv = SGGetFlags(s,
20140                      &sgFlags);
20141     _res = Py_BuildValue("ll",
20142                          _rv,
20143                          sgFlags);
20144     return _res;
20145 }
20146
20147 static PyObject *Qt_SGNewChannelFromComponent(PyObject *_self, PyObject *_args)
20148 {
20149     PyObject *_res = NULL;
20150     ComponentResult _rv;
20151     SeqGrabComponent s;
20152     SGChannel newChannel;
20153     Component sgChannelComponent;
20154 #ifndef SGNewChannelFromComponent
20155     PyMac_PRECHECK(SGNewChannelFromComponent);
20156 #endif
20157     if (!PyArg_ParseTuple(_args, "O&O&",
20158                           CmpInstObj_Convert, &s,
20159                           CmpObj_Convert, &sgChannelComponent))
20160         return NULL;
20161     _rv = SGNewChannelFromComponent(s,
20162                                     &newChannel,
20163                                     sgChannelComponent);
20164     _res = Py_BuildValue("lO&",
20165                          _rv,
20166                          CmpInstObj_New, newChannel);
20167     return _res;
20168 }
20169
20170 static PyObject *Qt_SGSetSettings(PyObject *_self, PyObject *_args)
20171 {
20172     PyObject *_res = NULL;
20173     ComponentResult _rv;
20174     SeqGrabComponent s;
20175     UserData ud;
20176     long flags;
20177 #ifndef SGSetSettings
20178     PyMac_PRECHECK(SGSetSettings);
20179 #endif
20180     if (!PyArg_ParseTuple(_args, "O&O&l",
20181                           CmpInstObj_Convert, &s,
20182                           UserDataObj_Convert, &ud,
20183                           &flags))
20184         return NULL;
20185     _rv = SGSetSettings(s,
20186                         ud,
20187                         flags);
20188     _res = Py_BuildValue("l",
20189                          _rv);
20190     return _res;
20191 }
20192
20193 static PyObject *Qt_SGGetSettings(PyObject *_self, PyObject *_args)
20194 {
20195     PyObject *_res = NULL;
20196     ComponentResult _rv;
20197     SeqGrabComponent s;
20198     UserData ud;
20199     long flags;
20200 #ifndef SGGetSettings
20201     PyMac_PRECHECK(SGGetSettings);
20202 #endif
20203     if (!PyArg_ParseTuple(_args, "O&l",
20204                           CmpInstObj_Convert, &s,
20205                           &flags))
20206         return NULL;
20207     _rv = SGGetSettings(s,
20208                         &ud,
20209                         flags);
20210     _res = Py_BuildValue("lO&",
20211                          _rv,
20212                          UserDataObj_New, ud);
20213     return _res;
20214 }
20215
20216 static PyObject *Qt_SGGetIndChannel(PyObject *_self, PyObject *_args)
20217 {
20218     PyObject *_res = NULL;
20219     ComponentResult _rv;
20220     SeqGrabComponent s;
20221     short index;
20222     SGChannel ref;
20223     OSType chanType;
20224 #ifndef SGGetIndChannel
20225     PyMac_PRECHECK(SGGetIndChannel);
20226 #endif
20227     if (!PyArg_ParseTuple(_args, "O&h",
20228                           CmpInstObj_Convert, &s,
20229                           &index))
20230         return NULL;
20231     _rv = SGGetIndChannel(s,
20232                           index,
20233                           &ref,
20234                           &chanType);
20235     _res = Py_BuildValue("lO&O&",
20236                          _rv,
20237                          CmpInstObj_New, ref,
20238                          PyMac_BuildOSType, chanType);
20239     return _res;
20240 }
20241
20242 static PyObject *Qt_SGUpdate(PyObject *_self, PyObject *_args)
20243 {
20244     PyObject *_res = NULL;
20245     ComponentResult _rv;
20246     SeqGrabComponent s;
20247     RgnHandle updateRgn;
20248 #ifndef SGUpdate
20249     PyMac_PRECHECK(SGUpdate);
20250 #endif
20251     if (!PyArg_ParseTuple(_args, "O&O&",
20252                           CmpInstObj_Convert, &s,
20253                           ResObj_Convert, &updateRgn))
20254         return NULL;
20255     _rv = SGUpdate(s,
20256                    updateRgn);
20257     _res = Py_BuildValue("l",
20258                          _rv);
20259     return _res;
20260 }
20261
20262 static PyObject *Qt_SGGetPause(PyObject *_self, PyObject *_args)
20263 {
20264     PyObject *_res = NULL;
20265     ComponentResult _rv;
20266     SeqGrabComponent s;
20267     Boolean paused;
20268 #ifndef SGGetPause
20269     PyMac_PRECHECK(SGGetPause);
20270 #endif
20271     if (!PyArg_ParseTuple(_args, "O&",
20272                           CmpInstObj_Convert, &s))
20273         return NULL;
20274     _rv = SGGetPause(s,
20275                      &paused);
20276     _res = Py_BuildValue("lb",
20277                          _rv,
20278                          paused);
20279     return _res;
20280 }
20281
20282 static PyObject *Qt_SGSetChannelSettings(PyObject *_self, PyObject *_args)
20283 {
20284     PyObject *_res = NULL;
20285     ComponentResult _rv;
20286     SeqGrabComponent s;
20287     SGChannel c;
20288     UserData ud;
20289     long flags;
20290 #ifndef SGSetChannelSettings
20291     PyMac_PRECHECK(SGSetChannelSettings);
20292 #endif
20293     if (!PyArg_ParseTuple(_args, "O&O&O&l",
20294                           CmpInstObj_Convert, &s,
20295                           CmpInstObj_Convert, &c,
20296                           UserDataObj_Convert, &ud,
20297                           &flags))
20298         return NULL;
20299     _rv = SGSetChannelSettings(s,
20300                                c,
20301                                ud,
20302                                flags);
20303     _res = Py_BuildValue("l",
20304                          _rv);
20305     return _res;
20306 }
20307
20308 static PyObject *Qt_SGGetChannelSettings(PyObject *_self, PyObject *_args)
20309 {
20310     PyObject *_res = NULL;
20311     ComponentResult _rv;
20312     SeqGrabComponent s;
20313     SGChannel c;
20314     UserData ud;
20315     long flags;
20316 #ifndef SGGetChannelSettings
20317     PyMac_PRECHECK(SGGetChannelSettings);
20318 #endif
20319     if (!PyArg_ParseTuple(_args, "O&O&l",
20320                           CmpInstObj_Convert, &s,
20321                           CmpInstObj_Convert, &c,
20322                           &flags))
20323         return NULL;
20324     _rv = SGGetChannelSettings(s,
20325                                c,
20326                                &ud,
20327                                flags);
20328     _res = Py_BuildValue("lO&",
20329                          _rv,
20330                          UserDataObj_New, ud);
20331     return _res;
20332 }
20333
20334 static PyObject *Qt_SGGetMode(PyObject *_self, PyObject *_args)
20335 {
20336     PyObject *_res = NULL;
20337     ComponentResult _rv;
20338     SeqGrabComponent s;
20339     Boolean previewMode;
20340     Boolean recordMode;
20341 #ifndef SGGetMode
20342     PyMac_PRECHECK(SGGetMode);
20343 #endif
20344     if (!PyArg_ParseTuple(_args, "O&",
20345                           CmpInstObj_Convert, &s))
20346         return NULL;
20347     _rv = SGGetMode(s,
20348                     &previewMode,
20349                     &recordMode);
20350     _res = Py_BuildValue("lbb",
20351                          _rv,
20352                          previewMode,
20353                          recordMode);
20354     return _res;
20355 }
20356
20357 static PyObject *Qt_SGSetDataRef(PyObject *_self, PyObject *_args)
20358 {
20359     PyObject *_res = NULL;
20360     ComponentResult _rv;
20361     SeqGrabComponent s;
20362     Handle dataRef;
20363     OSType dataRefType;
20364     long whereFlags;
20365 #ifndef SGSetDataRef
20366     PyMac_PRECHECK(SGSetDataRef);
20367 #endif
20368     if (!PyArg_ParseTuple(_args, "O&O&O&l",
20369                           CmpInstObj_Convert, &s,
20370                           ResObj_Convert, &dataRef,
20371                           PyMac_GetOSType, &dataRefType,
20372                           &whereFlags))
20373         return NULL;
20374     _rv = SGSetDataRef(s,
20375                        dataRef,
20376                        dataRefType,
20377                        whereFlags);
20378     _res = Py_BuildValue("l",
20379                          _rv);
20380     return _res;
20381 }
20382
20383 static PyObject *Qt_SGGetDataRef(PyObject *_self, PyObject *_args)
20384 {
20385     PyObject *_res = NULL;
20386     ComponentResult _rv;
20387     SeqGrabComponent s;
20388     Handle dataRef;
20389     OSType dataRefType;
20390     long whereFlags;
20391 #ifndef SGGetDataRef
20392     PyMac_PRECHECK(SGGetDataRef);
20393 #endif
20394     if (!PyArg_ParseTuple(_args, "O&",
20395                           CmpInstObj_Convert, &s))
20396         return NULL;
20397     _rv = SGGetDataRef(s,
20398                        &dataRef,
20399                        &dataRefType,
20400                        &whereFlags);
20401     _res = Py_BuildValue("lO&O&l",
20402                          _rv,
20403                          ResObj_New, dataRef,
20404                          PyMac_BuildOSType, dataRefType,
20405                          whereFlags);
20406     return _res;
20407 }
20408
20409 static PyObject *Qt_SGNewOutput(PyObject *_self, PyObject *_args)
20410 {
20411     PyObject *_res = NULL;
20412     ComponentResult _rv;
20413     SeqGrabComponent s;
20414     Handle dataRef;
20415     OSType dataRefType;
20416     long whereFlags;
20417     SGOutput sgOut;
20418 #ifndef SGNewOutput
20419     PyMac_PRECHECK(SGNewOutput);
20420 #endif
20421     if (!PyArg_ParseTuple(_args, "O&O&O&l",
20422                           CmpInstObj_Convert, &s,
20423                           ResObj_Convert, &dataRef,
20424                           PyMac_GetOSType, &dataRefType,
20425                           &whereFlags))
20426         return NULL;
20427     _rv = SGNewOutput(s,
20428                       dataRef,
20429                       dataRefType,
20430                       whereFlags,
20431                       &sgOut);
20432     _res = Py_BuildValue("lO&",
20433                          _rv,
20434                          SGOutputObj_New, sgOut);
20435     return _res;
20436 }
20437
20438 static PyObject *Qt_SGDisposeOutput(PyObject *_self, PyObject *_args)
20439 {
20440     PyObject *_res = NULL;
20441     ComponentResult _rv;
20442     SeqGrabComponent s;
20443     SGOutput sgOut;
20444 #ifndef SGDisposeOutput
20445     PyMac_PRECHECK(SGDisposeOutput);
20446 #endif
20447     if (!PyArg_ParseTuple(_args, "O&O&",
20448                           CmpInstObj_Convert, &s,
20449                           SGOutputObj_Convert, &sgOut))
20450         return NULL;
20451     _rv = SGDisposeOutput(s,
20452                           sgOut);
20453     _res = Py_BuildValue("l",
20454                          _rv);
20455     return _res;
20456 }
20457
20458 static PyObject *Qt_SGSetOutputFlags(PyObject *_self, PyObject *_args)
20459 {
20460     PyObject *_res = NULL;
20461     ComponentResult _rv;
20462     SeqGrabComponent s;
20463     SGOutput sgOut;
20464     long whereFlags;
20465 #ifndef SGSetOutputFlags
20466     PyMac_PRECHECK(SGSetOutputFlags);
20467 #endif
20468     if (!PyArg_ParseTuple(_args, "O&O&l",
20469                           CmpInstObj_Convert, &s,
20470                           SGOutputObj_Convert, &sgOut,
20471                           &whereFlags))
20472         return NULL;
20473     _rv = SGSetOutputFlags(s,
20474                            sgOut,
20475                            whereFlags);
20476     _res = Py_BuildValue("l",
20477                          _rv);
20478     return _res;
20479 }
20480
20481 static PyObject *Qt_SGSetChannelOutput(PyObject *_self, PyObject *_args)
20482 {
20483     PyObject *_res = NULL;
20484     ComponentResult _rv;
20485     SeqGrabComponent s;
20486     SGChannel c;
20487     SGOutput sgOut;
20488 #ifndef SGSetChannelOutput
20489     PyMac_PRECHECK(SGSetChannelOutput);
20490 #endif
20491     if (!PyArg_ParseTuple(_args, "O&O&O&",
20492                           CmpInstObj_Convert, &s,
20493                           CmpInstObj_Convert, &c,
20494                           SGOutputObj_Convert, &sgOut))
20495         return NULL;
20496     _rv = SGSetChannelOutput(s,
20497                              c,
20498                              sgOut);
20499     _res = Py_BuildValue("l",
20500                          _rv);
20501     return _res;
20502 }
20503
20504 static PyObject *Qt_SGGetDataOutputStorageSpaceRemaining(PyObject *_self, PyObject *_args)
20505 {
20506     PyObject *_res = NULL;
20507     ComponentResult _rv;
20508     SeqGrabComponent s;
20509     SGOutput sgOut;
20510     unsigned long space;
20511 #ifndef SGGetDataOutputStorageSpaceRemaining
20512     PyMac_PRECHECK(SGGetDataOutputStorageSpaceRemaining);
20513 #endif
20514     if (!PyArg_ParseTuple(_args, "O&O&",
20515                           CmpInstObj_Convert, &s,
20516                           SGOutputObj_Convert, &sgOut))
20517         return NULL;
20518     _rv = SGGetDataOutputStorageSpaceRemaining(s,
20519                                                sgOut,
20520                                                &space);
20521     _res = Py_BuildValue("ll",
20522                          _rv,
20523                          space);
20524     return _res;
20525 }
20526
20527 static PyObject *Qt_SGHandleUpdateEvent(PyObject *_self, PyObject *_args)
20528 {
20529     PyObject *_res = NULL;
20530     ComponentResult _rv;
20531     SeqGrabComponent s;
20532     EventRecord event;
20533     Boolean handled;
20534 #ifndef SGHandleUpdateEvent
20535     PyMac_PRECHECK(SGHandleUpdateEvent);
20536 #endif
20537     if (!PyArg_ParseTuple(_args, "O&O&",
20538                           CmpInstObj_Convert, &s,
20539                           PyMac_GetEventRecord, &event))
20540         return NULL;
20541     _rv = SGHandleUpdateEvent(s,
20542                               &event,
20543                               &handled);
20544     _res = Py_BuildValue("lb",
20545                          _rv,
20546                          handled);
20547     return _res;
20548 }
20549
20550 static PyObject *Qt_SGSetOutputNextOutput(PyObject *_self, PyObject *_args)
20551 {
20552     PyObject *_res = NULL;
20553     ComponentResult _rv;
20554     SeqGrabComponent s;
20555     SGOutput sgOut;
20556     SGOutput nextOut;
20557 #ifndef SGSetOutputNextOutput
20558     PyMac_PRECHECK(SGSetOutputNextOutput);
20559 #endif
20560     if (!PyArg_ParseTuple(_args, "O&O&O&",
20561                           CmpInstObj_Convert, &s,
20562                           SGOutputObj_Convert, &sgOut,
20563                           SGOutputObj_Convert, &nextOut))
20564         return NULL;
20565     _rv = SGSetOutputNextOutput(s,
20566                                 sgOut,
20567                                 nextOut);
20568     _res = Py_BuildValue("l",
20569                          _rv);
20570     return _res;
20571 }
20572
20573 static PyObject *Qt_SGGetOutputNextOutput(PyObject *_self, PyObject *_args)
20574 {
20575     PyObject *_res = NULL;
20576     ComponentResult _rv;
20577     SeqGrabComponent s;
20578     SGOutput sgOut;
20579     SGOutput nextOut;
20580 #ifndef SGGetOutputNextOutput
20581     PyMac_PRECHECK(SGGetOutputNextOutput);
20582 #endif
20583     if (!PyArg_ParseTuple(_args, "O&O&",
20584                           CmpInstObj_Convert, &s,
20585                           SGOutputObj_Convert, &sgOut))
20586         return NULL;
20587     _rv = SGGetOutputNextOutput(s,
20588                                 sgOut,
20589                                 &nextOut);
20590     _res = Py_BuildValue("lO&",
20591                          _rv,
20592                          SGOutputObj_New, nextOut);
20593     return _res;
20594 }
20595
20596 static PyObject *Qt_SGSetOutputMaximumOffset(PyObject *_self, PyObject *_args)
20597 {
20598     PyObject *_res = NULL;
20599     ComponentResult _rv;
20600     SeqGrabComponent s;
20601     SGOutput sgOut;
20602     wide maxOffset;
20603 #ifndef SGSetOutputMaximumOffset
20604     PyMac_PRECHECK(SGSetOutputMaximumOffset);
20605 #endif
20606     if (!PyArg_ParseTuple(_args, "O&O&O&",
20607                           CmpInstObj_Convert, &s,
20608                           SGOutputObj_Convert, &sgOut,
20609                           PyMac_Getwide, &maxOffset))
20610         return NULL;
20611     _rv = SGSetOutputMaximumOffset(s,
20612                                    sgOut,
20613                                    &maxOffset);
20614     _res = Py_BuildValue("l",
20615                          _rv);
20616     return _res;
20617 }
20618
20619 static PyObject *Qt_SGGetOutputMaximumOffset(PyObject *_self, PyObject *_args)
20620 {
20621     PyObject *_res = NULL;
20622     ComponentResult _rv;
20623     SeqGrabComponent s;
20624     SGOutput sgOut;
20625     wide maxOffset;
20626 #ifndef SGGetOutputMaximumOffset
20627     PyMac_PRECHECK(SGGetOutputMaximumOffset);
20628 #endif
20629     if (!PyArg_ParseTuple(_args, "O&O&",
20630                           CmpInstObj_Convert, &s,
20631                           SGOutputObj_Convert, &sgOut))
20632         return NULL;
20633     _rv = SGGetOutputMaximumOffset(s,
20634                                    sgOut,
20635                                    &maxOffset);
20636     _res = Py_BuildValue("lO&",
20637                          _rv,
20638                          PyMac_Buildwide, maxOffset);
20639     return _res;
20640 }
20641
20642 static PyObject *Qt_SGGetOutputDataReference(PyObject *_self, PyObject *_args)
20643 {
20644     PyObject *_res = NULL;
20645     ComponentResult _rv;
20646     SeqGrabComponent s;
20647     SGOutput sgOut;
20648     Handle dataRef;
20649     OSType dataRefType;
20650 #ifndef SGGetOutputDataReference
20651     PyMac_PRECHECK(SGGetOutputDataReference);
20652 #endif
20653     if (!PyArg_ParseTuple(_args, "O&O&",
20654                           CmpInstObj_Convert, &s,
20655                           SGOutputObj_Convert, &sgOut))
20656         return NULL;
20657     _rv = SGGetOutputDataReference(s,
20658                                    sgOut,
20659                                    &dataRef,
20660                                    &dataRefType);
20661     _res = Py_BuildValue("lO&O&",
20662                          _rv,
20663                          ResObj_New, dataRef,
20664                          PyMac_BuildOSType, dataRefType);
20665     return _res;
20666 }
20667
20668 static PyObject *Qt_SGWriteExtendedMovieData(PyObject *_self, PyObject *_args)
20669 {
20670     PyObject *_res = NULL;
20671     ComponentResult _rv;
20672     SeqGrabComponent s;
20673     SGChannel c;
20674     Ptr p;
20675     long len;
20676     wide offset;
20677     SGOutput sgOut;
20678 #ifndef SGWriteExtendedMovieData
20679     PyMac_PRECHECK(SGWriteExtendedMovieData);
20680 #endif
20681     if (!PyArg_ParseTuple(_args, "O&O&sl",
20682                           CmpInstObj_Convert, &s,
20683                           CmpInstObj_Convert, &c,
20684                           &p,
20685                           &len))
20686         return NULL;
20687     _rv = SGWriteExtendedMovieData(s,
20688                                    c,
20689                                    p,
20690                                    len,
20691                                    &offset,
20692                                    &sgOut);
20693     _res = Py_BuildValue("lO&O&",
20694                          _rv,
20695                          PyMac_Buildwide, offset,
20696                          SGOutputObj_New, sgOut);
20697     return _res;
20698 }
20699
20700 static PyObject *Qt_SGGetStorageSpaceRemaining64(PyObject *_self, PyObject *_args)
20701 {
20702     PyObject *_res = NULL;
20703     ComponentResult _rv;
20704     SeqGrabComponent s;
20705     wide bytes;
20706 #ifndef SGGetStorageSpaceRemaining64
20707     PyMac_PRECHECK(SGGetStorageSpaceRemaining64);
20708 #endif
20709     if (!PyArg_ParseTuple(_args, "O&",
20710                           CmpInstObj_Convert, &s))
20711         return NULL;
20712     _rv = SGGetStorageSpaceRemaining64(s,
20713                                        &bytes);
20714     _res = Py_BuildValue("lO&",
20715                          _rv,
20716                          PyMac_Buildwide, bytes);
20717     return _res;
20718 }
20719
20720 static PyObject *Qt_SGGetDataOutputStorageSpaceRemaining64(PyObject *_self, PyObject *_args)
20721 {
20722     PyObject *_res = NULL;
20723     ComponentResult _rv;
20724     SeqGrabComponent s;
20725     SGOutput sgOut;
20726     wide space;
20727 #ifndef SGGetDataOutputStorageSpaceRemaining64
20728     PyMac_PRECHECK(SGGetDataOutputStorageSpaceRemaining64);
20729 #endif
20730     if (!PyArg_ParseTuple(_args, "O&O&",
20731                           CmpInstObj_Convert, &s,
20732                           SGOutputObj_Convert, &sgOut))
20733         return NULL;
20734     _rv = SGGetDataOutputStorageSpaceRemaining64(s,
20735                                                  sgOut,
20736                                                  &space);
20737     _res = Py_BuildValue("lO&",
20738                          _rv,
20739                          PyMac_Buildwide, space);
20740     return _res;
20741 }
20742
20743 static PyObject *Qt_SGWriteMovieData(PyObject *_self, PyObject *_args)
20744 {
20745     PyObject *_res = NULL;
20746     ComponentResult _rv;
20747     SeqGrabComponent s;
20748     SGChannel c;
20749     Ptr p;
20750     long len;
20751     long offset;
20752 #ifndef SGWriteMovieData
20753     PyMac_PRECHECK(SGWriteMovieData);
20754 #endif
20755     if (!PyArg_ParseTuple(_args, "O&O&sl",
20756                           CmpInstObj_Convert, &s,
20757                           CmpInstObj_Convert, &c,
20758                           &p,
20759                           &len))
20760         return NULL;
20761     _rv = SGWriteMovieData(s,
20762                            c,
20763                            p,
20764                            len,
20765                            &offset);
20766     _res = Py_BuildValue("ll",
20767                          _rv,
20768                          offset);
20769     return _res;
20770 }
20771
20772 static PyObject *Qt_SGGetTimeBase(PyObject *_self, PyObject *_args)
20773 {
20774     PyObject *_res = NULL;
20775     ComponentResult _rv;
20776     SeqGrabComponent s;
20777     TimeBase tb;
20778 #ifndef SGGetTimeBase
20779     PyMac_PRECHECK(SGGetTimeBase);
20780 #endif
20781     if (!PyArg_ParseTuple(_args, "O&",
20782                           CmpInstObj_Convert, &s))
20783         return NULL;
20784     _rv = SGGetTimeBase(s,
20785                         &tb);
20786     _res = Py_BuildValue("lO&",
20787                          _rv,
20788                          TimeBaseObj_New, tb);
20789     return _res;
20790 }
20791
20792 static PyObject *Qt_SGAddMovieData(PyObject *_self, PyObject *_args)
20793 {
20794     PyObject *_res = NULL;
20795     ComponentResult _rv;
20796     SeqGrabComponent s;
20797     SGChannel c;
20798     Ptr p;
20799     long len;
20800     long offset;
20801     long chRefCon;
20802     TimeValue time;
20803     short writeType;
20804 #ifndef SGAddMovieData
20805     PyMac_PRECHECK(SGAddMovieData);
20806 #endif
20807     if (!PyArg_ParseTuple(_args, "O&O&slllh",
20808                           CmpInstObj_Convert, &s,
20809                           CmpInstObj_Convert, &c,
20810                           &p,
20811                           &len,
20812                           &chRefCon,
20813                           &time,
20814                           &writeType))
20815         return NULL;
20816     _rv = SGAddMovieData(s,
20817                          c,
20818                          p,
20819                          len,
20820                          &offset,
20821                          chRefCon,
20822                          time,
20823                          writeType);
20824     _res = Py_BuildValue("ll",
20825                          _rv,
20826                          offset);
20827     return _res;
20828 }
20829
20830 static PyObject *Qt_SGChangedSource(PyObject *_self, PyObject *_args)
20831 {
20832     PyObject *_res = NULL;
20833     ComponentResult _rv;
20834     SeqGrabComponent s;
20835     SGChannel c;
20836 #ifndef SGChangedSource
20837     PyMac_PRECHECK(SGChangedSource);
20838 #endif
20839     if (!PyArg_ParseTuple(_args, "O&O&",
20840                           CmpInstObj_Convert, &s,
20841                           CmpInstObj_Convert, &c))
20842         return NULL;
20843     _rv = SGChangedSource(s,
20844                           c);
20845     _res = Py_BuildValue("l",
20846                          _rv);
20847     return _res;
20848 }
20849
20850 static PyObject *Qt_SGAddExtendedMovieData(PyObject *_self, PyObject *_args)
20851 {
20852     PyObject *_res = NULL;
20853     ComponentResult _rv;
20854     SeqGrabComponent s;
20855     SGChannel c;
20856     Ptr p;
20857     long len;
20858     wide offset;
20859     long chRefCon;
20860     TimeValue time;
20861     short writeType;
20862     SGOutput whichOutput;
20863 #ifndef SGAddExtendedMovieData
20864     PyMac_PRECHECK(SGAddExtendedMovieData);
20865 #endif
20866     if (!PyArg_ParseTuple(_args, "O&O&slllh",
20867                           CmpInstObj_Convert, &s,
20868                           CmpInstObj_Convert, &c,
20869                           &p,
20870                           &len,
20871                           &chRefCon,
20872                           &time,
20873                           &writeType))
20874         return NULL;
20875     _rv = SGAddExtendedMovieData(s,
20876                                  c,
20877                                  p,
20878                                  len,
20879                                  &offset,
20880                                  chRefCon,
20881                                  time,
20882                                  writeType,
20883                                  &whichOutput);
20884     _res = Py_BuildValue("lO&O&",
20885                          _rv,
20886                          PyMac_Buildwide, offset,
20887                          SGOutputObj_New, whichOutput);
20888     return _res;
20889 }
20890
20891 static PyObject *Qt_SGAddOutputDataRefToMedia(PyObject *_self, PyObject *_args)
20892 {
20893     PyObject *_res = NULL;
20894     ComponentResult _rv;
20895     SeqGrabComponent s;
20896     SGOutput sgOut;
20897     Media theMedia;
20898     SampleDescriptionHandle desc;
20899 #ifndef SGAddOutputDataRefToMedia
20900     PyMac_PRECHECK(SGAddOutputDataRefToMedia);
20901 #endif
20902     if (!PyArg_ParseTuple(_args, "O&O&O&O&",
20903                           CmpInstObj_Convert, &s,
20904                           SGOutputObj_Convert, &sgOut,
20905                           MediaObj_Convert, &theMedia,
20906                           ResObj_Convert, &desc))
20907         return NULL;
20908     _rv = SGAddOutputDataRefToMedia(s,
20909                                     sgOut,
20910                                     theMedia,
20911                                     desc);
20912     _res = Py_BuildValue("l",
20913                          _rv);
20914     return _res;
20915 }
20916
20917 static PyObject *Qt_SGSetSettingsSummary(PyObject *_self, PyObject *_args)
20918 {
20919     PyObject *_res = NULL;
20920     ComponentResult _rv;
20921     SeqGrabComponent s;
20922     Handle summaryText;
20923 #ifndef SGSetSettingsSummary
20924     PyMac_PRECHECK(SGSetSettingsSummary);
20925 #endif
20926     if (!PyArg_ParseTuple(_args, "O&O&",
20927                           CmpInstObj_Convert, &s,
20928                           ResObj_Convert, &summaryText))
20929         return NULL;
20930     _rv = SGSetSettingsSummary(s,
20931                                summaryText);
20932     _res = Py_BuildValue("l",
20933                          _rv);
20934     return _res;
20935 }
20936
20937 static PyObject *Qt_SGSetChannelUsage(PyObject *_self, PyObject *_args)
20938 {
20939     PyObject *_res = NULL;
20940     ComponentResult _rv;
20941     SGChannel c;
20942     long usage;
20943 #ifndef SGSetChannelUsage
20944     PyMac_PRECHECK(SGSetChannelUsage);
20945 #endif
20946     if (!PyArg_ParseTuple(_args, "O&l",
20947                           CmpInstObj_Convert, &c,
20948                           &usage))
20949         return NULL;
20950     _rv = SGSetChannelUsage(c,
20951                             usage);
20952     _res = Py_BuildValue("l",
20953                          _rv);
20954     return _res;
20955 }
20956
20957 static PyObject *Qt_SGGetChannelUsage(PyObject *_self, PyObject *_args)
20958 {
20959     PyObject *_res = NULL;
20960     ComponentResult _rv;
20961     SGChannel c;
20962     long usage;
20963 #ifndef SGGetChannelUsage
20964     PyMac_PRECHECK(SGGetChannelUsage);
20965 #endif
20966     if (!PyArg_ParseTuple(_args, "O&",
20967                           CmpInstObj_Convert, &c))
20968         return NULL;
20969     _rv = SGGetChannelUsage(c,
20970                             &usage);
20971     _res = Py_BuildValue("ll",
20972                          _rv,
20973                          usage);
20974     return _res;
20975 }
20976
20977 static PyObject *Qt_SGSetChannelBounds(PyObject *_self, PyObject *_args)
20978 {
20979     PyObject *_res = NULL;
20980     ComponentResult _rv;
20981     SGChannel c;
20982     Rect bounds;
20983 #ifndef SGSetChannelBounds
20984     PyMac_PRECHECK(SGSetChannelBounds);
20985 #endif
20986     if (!PyArg_ParseTuple(_args, "O&O&",
20987                           CmpInstObj_Convert, &c,
20988                           PyMac_GetRect, &bounds))
20989         return NULL;
20990     _rv = SGSetChannelBounds(c,
20991                              &bounds);
20992     _res = Py_BuildValue("l",
20993                          _rv);
20994     return _res;
20995 }
20996
20997 static PyObject *Qt_SGGetChannelBounds(PyObject *_self, PyObject *_args)
20998 {
20999     PyObject *_res = NULL;
21000     ComponentResult _rv;
21001     SGChannel c;
21002     Rect bounds;
21003 #ifndef SGGetChannelBounds
21004     PyMac_PRECHECK(SGGetChannelBounds);
21005 #endif
21006     if (!PyArg_ParseTuple(_args, "O&",
21007                           CmpInstObj_Convert, &c))
21008         return NULL;
21009     _rv = SGGetChannelBounds(c,
21010                              &bounds);
21011     _res = Py_BuildValue("lO&",
21012                          _rv,
21013                          PyMac_BuildRect, &bounds);
21014     return _res;
21015 }
21016
21017 static PyObject *Qt_SGSetChannelVolume(PyObject *_self, PyObject *_args)
21018 {
21019     PyObject *_res = NULL;
21020     ComponentResult _rv;
21021     SGChannel c;
21022     short volume;
21023 #ifndef SGSetChannelVolume
21024     PyMac_PRECHECK(SGSetChannelVolume);
21025 #endif
21026     if (!PyArg_ParseTuple(_args, "O&h",
21027                           CmpInstObj_Convert, &c,
21028                           &volume))
21029         return NULL;
21030     _rv = SGSetChannelVolume(c,
21031                              volume);
21032     _res = Py_BuildValue("l",
21033                          _rv);
21034     return _res;
21035 }
21036
21037 static PyObject *Qt_SGGetChannelVolume(PyObject *_self, PyObject *_args)
21038 {
21039     PyObject *_res = NULL;
21040     ComponentResult _rv;
21041     SGChannel c;
21042     short volume;
21043 #ifndef SGGetChannelVolume
21044     PyMac_PRECHECK(SGGetChannelVolume);
21045 #endif
21046     if (!PyArg_ParseTuple(_args, "O&",
21047                           CmpInstObj_Convert, &c))
21048         return NULL;
21049     _rv = SGGetChannelVolume(c,
21050                              &volume);
21051     _res = Py_BuildValue("lh",
21052                          _rv,
21053                          volume);
21054     return _res;
21055 }
21056
21057 static PyObject *Qt_SGGetChannelInfo(PyObject *_self, PyObject *_args)
21058 {
21059     PyObject *_res = NULL;
21060     ComponentResult _rv;
21061     SGChannel c;
21062     long channelInfo;
21063 #ifndef SGGetChannelInfo
21064     PyMac_PRECHECK(SGGetChannelInfo);
21065 #endif
21066     if (!PyArg_ParseTuple(_args, "O&",
21067                           CmpInstObj_Convert, &c))
21068         return NULL;
21069     _rv = SGGetChannelInfo(c,
21070                            &channelInfo);
21071     _res = Py_BuildValue("ll",
21072                          _rv,
21073                          channelInfo);
21074     return _res;
21075 }
21076
21077 static PyObject *Qt_SGSetChannelPlayFlags(PyObject *_self, PyObject *_args)
21078 {
21079     PyObject *_res = NULL;
21080     ComponentResult _rv;
21081     SGChannel c;
21082     long playFlags;
21083 #ifndef SGSetChannelPlayFlags
21084     PyMac_PRECHECK(SGSetChannelPlayFlags);
21085 #endif
21086     if (!PyArg_ParseTuple(_args, "O&l",
21087                           CmpInstObj_Convert, &c,
21088                           &playFlags))
21089         return NULL;
21090     _rv = SGSetChannelPlayFlags(c,
21091                                 playFlags);
21092     _res = Py_BuildValue("l",
21093                          _rv);
21094     return _res;
21095 }
21096
21097 static PyObject *Qt_SGGetChannelPlayFlags(PyObject *_self, PyObject *_args)
21098 {
21099     PyObject *_res = NULL;
21100     ComponentResult _rv;
21101     SGChannel c;
21102     long playFlags;
21103 #ifndef SGGetChannelPlayFlags
21104     PyMac_PRECHECK(SGGetChannelPlayFlags);
21105 #endif
21106     if (!PyArg_ParseTuple(_args, "O&",
21107                           CmpInstObj_Convert, &c))
21108         return NULL;
21109     _rv = SGGetChannelPlayFlags(c,
21110                                 &playFlags);
21111     _res = Py_BuildValue("ll",
21112                          _rv,
21113                          playFlags);
21114     return _res;
21115 }
21116
21117 static PyObject *Qt_SGSetChannelMaxFrames(PyObject *_self, PyObject *_args)
21118 {
21119     PyObject *_res = NULL;
21120     ComponentResult _rv;
21121     SGChannel c;
21122     long frameCount;
21123 #ifndef SGSetChannelMaxFrames
21124     PyMac_PRECHECK(SGSetChannelMaxFrames);
21125 #endif
21126     if (!PyArg_ParseTuple(_args, "O&l",
21127                           CmpInstObj_Convert, &c,
21128                           &frameCount))
21129         return NULL;
21130     _rv = SGSetChannelMaxFrames(c,
21131                                 frameCount);
21132     _res = Py_BuildValue("l",
21133                          _rv);
21134     return _res;
21135 }
21136
21137 static PyObject *Qt_SGGetChannelMaxFrames(PyObject *_self, PyObject *_args)
21138 {
21139     PyObject *_res = NULL;
21140     ComponentResult _rv;
21141     SGChannel c;
21142     long frameCount;
21143 #ifndef SGGetChannelMaxFrames
21144     PyMac_PRECHECK(SGGetChannelMaxFrames);
21145 #endif
21146     if (!PyArg_ParseTuple(_args, "O&",
21147                           CmpInstObj_Convert, &c))
21148         return NULL;
21149     _rv = SGGetChannelMaxFrames(c,
21150                                 &frameCount);
21151     _res = Py_BuildValue("ll",
21152                          _rv,
21153                          frameCount);
21154     return _res;
21155 }
21156
21157 static PyObject *Qt_SGSetChannelRefCon(PyObject *_self, PyObject *_args)
21158 {
21159     PyObject *_res = NULL;
21160     ComponentResult _rv;
21161     SGChannel c;
21162     long refCon;
21163 #ifndef SGSetChannelRefCon
21164     PyMac_PRECHECK(SGSetChannelRefCon);
21165 #endif
21166     if (!PyArg_ParseTuple(_args, "O&l",
21167                           CmpInstObj_Convert, &c,
21168                           &refCon))
21169         return NULL;
21170     _rv = SGSetChannelRefCon(c,
21171                              refCon);
21172     _res = Py_BuildValue("l",
21173                          _rv);
21174     return _res;
21175 }
21176
21177 static PyObject *Qt_SGSetChannelClip(PyObject *_self, PyObject *_args)
21178 {
21179     PyObject *_res = NULL;
21180     ComponentResult _rv;
21181     SGChannel c;
21182     RgnHandle theClip;
21183 #ifndef SGSetChannelClip
21184     PyMac_PRECHECK(SGSetChannelClip);
21185 #endif
21186     if (!PyArg_ParseTuple(_args, "O&O&",
21187                           CmpInstObj_Convert, &c,
21188                           ResObj_Convert, &theClip))
21189         return NULL;
21190     _rv = SGSetChannelClip(c,
21191                            theClip);
21192     _res = Py_BuildValue("l",
21193                          _rv);
21194     return _res;
21195 }
21196
21197 static PyObject *Qt_SGGetChannelClip(PyObject *_self, PyObject *_args)
21198 {
21199     PyObject *_res = NULL;
21200     ComponentResult _rv;
21201     SGChannel c;
21202     RgnHandle theClip;
21203 #ifndef SGGetChannelClip
21204     PyMac_PRECHECK(SGGetChannelClip);
21205 #endif
21206     if (!PyArg_ParseTuple(_args, "O&",
21207                           CmpInstObj_Convert, &c))
21208         return NULL;
21209     _rv = SGGetChannelClip(c,
21210                            &theClip);
21211     _res = Py_BuildValue("lO&",
21212                          _rv,
21213                          ResObj_New, theClip);
21214     return _res;
21215 }
21216
21217 static PyObject *Qt_SGGetChannelSampleDescription(PyObject *_self, PyObject *_args)
21218 {
21219     PyObject *_res = NULL;
21220     ComponentResult _rv;
21221     SGChannel c;
21222     Handle sampleDesc;
21223 #ifndef SGGetChannelSampleDescription
21224     PyMac_PRECHECK(SGGetChannelSampleDescription);
21225 #endif
21226     if (!PyArg_ParseTuple(_args, "O&O&",
21227                           CmpInstObj_Convert, &c,
21228                           ResObj_Convert, &sampleDesc))
21229         return NULL;
21230     _rv = SGGetChannelSampleDescription(c,
21231                                         sampleDesc);
21232     _res = Py_BuildValue("l",
21233                          _rv);
21234     return _res;
21235 }
21236
21237 static PyObject *Qt_SGSetChannelDevice(PyObject *_self, PyObject *_args)
21238 {
21239     PyObject *_res = NULL;
21240     ComponentResult _rv;
21241     SGChannel c;
21242     StringPtr name;
21243 #ifndef SGSetChannelDevice
21244     PyMac_PRECHECK(SGSetChannelDevice);
21245 #endif
21246     if (!PyArg_ParseTuple(_args, "O&s",
21247                           CmpInstObj_Convert, &c,
21248                           &name))
21249         return NULL;
21250     _rv = SGSetChannelDevice(c,
21251                              name);
21252     _res = Py_BuildValue("l",
21253                          _rv);
21254     return _res;
21255 }
21256
21257 static PyObject *Qt_SGGetChannelTimeScale(PyObject *_self, PyObject *_args)
21258 {
21259     PyObject *_res = NULL;
21260     ComponentResult _rv;
21261     SGChannel c;
21262     TimeScale scale;
21263 #ifndef SGGetChannelTimeScale
21264     PyMac_PRECHECK(SGGetChannelTimeScale);
21265 #endif
21266     if (!PyArg_ParseTuple(_args, "O&",
21267                           CmpInstObj_Convert, &c))
21268         return NULL;
21269     _rv = SGGetChannelTimeScale(c,
21270                                 &scale);
21271     _res = Py_BuildValue("ll",
21272                          _rv,
21273                          scale);
21274     return _res;
21275 }
21276
21277 static PyObject *Qt_SGChannelPutPicture(PyObject *_self, PyObject *_args)
21278 {
21279     PyObject *_res = NULL;
21280     ComponentResult _rv;
21281     SGChannel c;
21282 #ifndef SGChannelPutPicture
21283     PyMac_PRECHECK(SGChannelPutPicture);
21284 #endif
21285     if (!PyArg_ParseTuple(_args, "O&",
21286                           CmpInstObj_Convert, &c))
21287         return NULL;
21288     _rv = SGChannelPutPicture(c);
21289     _res = Py_BuildValue("l",
21290                          _rv);
21291     return _res;
21292 }
21293
21294 static PyObject *Qt_SGChannelSetRequestedDataRate(PyObject *_self, PyObject *_args)
21295 {
21296     PyObject *_res = NULL;
21297     ComponentResult _rv;
21298     SGChannel c;
21299     long bytesPerSecond;
21300 #ifndef SGChannelSetRequestedDataRate
21301     PyMac_PRECHECK(SGChannelSetRequestedDataRate);
21302 #endif
21303     if (!PyArg_ParseTuple(_args, "O&l",
21304                           CmpInstObj_Convert, &c,
21305                           &bytesPerSecond))
21306         return NULL;
21307     _rv = SGChannelSetRequestedDataRate(c,
21308                                         bytesPerSecond);
21309     _res = Py_BuildValue("l",
21310                          _rv);
21311     return _res;
21312 }
21313
21314 static PyObject *Qt_SGChannelGetRequestedDataRate(PyObject *_self, PyObject *_args)
21315 {
21316     PyObject *_res = NULL;
21317     ComponentResult _rv;
21318     SGChannel c;
21319     long bytesPerSecond;
21320 #ifndef SGChannelGetRequestedDataRate
21321     PyMac_PRECHECK(SGChannelGetRequestedDataRate);
21322 #endif
21323     if (!PyArg_ParseTuple(_args, "O&",
21324                           CmpInstObj_Convert, &c))
21325         return NULL;
21326     _rv = SGChannelGetRequestedDataRate(c,
21327                                         &bytesPerSecond);
21328     _res = Py_BuildValue("ll",
21329                          _rv,
21330                          bytesPerSecond);
21331     return _res;
21332 }
21333
21334 static PyObject *Qt_SGChannelSetDataSourceName(PyObject *_self, PyObject *_args)
21335 {
21336     PyObject *_res = NULL;
21337     ComponentResult _rv;
21338     SGChannel c;
21339     Str255 name;
21340     ScriptCode scriptTag;
21341 #ifndef SGChannelSetDataSourceName
21342     PyMac_PRECHECK(SGChannelSetDataSourceName);
21343 #endif
21344     if (!PyArg_ParseTuple(_args, "O&O&h",
21345                           CmpInstObj_Convert, &c,
21346                           PyMac_GetStr255, name,
21347                           &scriptTag))
21348         return NULL;
21349     _rv = SGChannelSetDataSourceName(c,
21350                                      name,
21351                                      scriptTag);
21352     _res = Py_BuildValue("l",
21353                          _rv);
21354     return _res;
21355 }
21356
21357 static PyObject *Qt_SGChannelGetDataSourceName(PyObject *_self, PyObject *_args)
21358 {
21359     PyObject *_res = NULL;
21360     ComponentResult _rv;
21361     SGChannel c;
21362     Str255 name;
21363     ScriptCode scriptTag;
21364 #ifndef SGChannelGetDataSourceName
21365     PyMac_PRECHECK(SGChannelGetDataSourceName);
21366 #endif
21367     if (!PyArg_ParseTuple(_args, "O&O&",
21368                           CmpInstObj_Convert, &c,
21369                           PyMac_GetStr255, name))
21370         return NULL;
21371     _rv = SGChannelGetDataSourceName(c,
21372                                      name,
21373                                      &scriptTag);
21374     _res = Py_BuildValue("lh",
21375                          _rv,
21376                          scriptTag);
21377     return _res;
21378 }
21379
21380 static PyObject *Qt_SGChannelSetCodecSettings(PyObject *_self, PyObject *_args)
21381 {
21382     PyObject *_res = NULL;
21383     ComponentResult _rv;
21384     SGChannel c;
21385     Handle settings;
21386 #ifndef SGChannelSetCodecSettings
21387     PyMac_PRECHECK(SGChannelSetCodecSettings);
21388 #endif
21389     if (!PyArg_ParseTuple(_args, "O&O&",
21390                           CmpInstObj_Convert, &c,
21391                           ResObj_Convert, &settings))
21392         return NULL;
21393     _rv = SGChannelSetCodecSettings(c,
21394                                     settings);
21395     _res = Py_BuildValue("l",
21396                          _rv);
21397     return _res;
21398 }
21399
21400 static PyObject *Qt_SGChannelGetCodecSettings(PyObject *_self, PyObject *_args)
21401 {
21402     PyObject *_res = NULL;
21403     ComponentResult _rv;
21404     SGChannel c;
21405     Handle settings;
21406 #ifndef SGChannelGetCodecSettings
21407     PyMac_PRECHECK(SGChannelGetCodecSettings);
21408 #endif
21409     if (!PyArg_ParseTuple(_args, "O&",
21410                           CmpInstObj_Convert, &c))
21411         return NULL;
21412     _rv = SGChannelGetCodecSettings(c,
21413                                     &settings);
21414     _res = Py_BuildValue("lO&",
21415                          _rv,
21416                          ResObj_New, settings);
21417     return _res;
21418 }
21419
21420 static PyObject *Qt_SGGetChannelTimeBase(PyObject *_self, PyObject *_args)
21421 {
21422     PyObject *_res = NULL;
21423     ComponentResult _rv;
21424     SGChannel c;
21425     TimeBase tb;
21426 #ifndef SGGetChannelTimeBase
21427     PyMac_PRECHECK(SGGetChannelTimeBase);
21428 #endif
21429     if (!PyArg_ParseTuple(_args, "O&",
21430                           CmpInstObj_Convert, &c))
21431         return NULL;
21432     _rv = SGGetChannelTimeBase(c,
21433                                &tb);
21434     _res = Py_BuildValue("lO&",
21435                          _rv,
21436                          TimeBaseObj_New, tb);
21437     return _res;
21438 }
21439
21440 static PyObject *Qt_SGGetChannelRefCon(PyObject *_self, PyObject *_args)
21441 {
21442     PyObject *_res = NULL;
21443     ComponentResult _rv;
21444     SGChannel c;
21445     long refCon;
21446 #ifndef SGGetChannelRefCon
21447     PyMac_PRECHECK(SGGetChannelRefCon);
21448 #endif
21449     if (!PyArg_ParseTuple(_args, "O&",
21450                           CmpInstObj_Convert, &c))
21451         return NULL;
21452     _rv = SGGetChannelRefCon(c,
21453                              &refCon);
21454     _res = Py_BuildValue("ll",
21455                          _rv,
21456                          refCon);
21457     return _res;
21458 }
21459
21460 static PyObject *Qt_SGGetChannelDeviceAndInputNames(PyObject *_self, PyObject *_args)
21461 {
21462     PyObject *_res = NULL;
21463     ComponentResult _rv;
21464     SGChannel c;
21465     Str255 outDeviceName;
21466     Str255 outInputName;
21467     short outInputNumber;
21468 #ifndef SGGetChannelDeviceAndInputNames
21469     PyMac_PRECHECK(SGGetChannelDeviceAndInputNames);
21470 #endif
21471     if (!PyArg_ParseTuple(_args, "O&O&O&",
21472                           CmpInstObj_Convert, &c,
21473                           PyMac_GetStr255, outDeviceName,
21474                           PyMac_GetStr255, outInputName))
21475         return NULL;
21476     _rv = SGGetChannelDeviceAndInputNames(c,
21477                                           outDeviceName,
21478                                           outInputName,
21479                                           &outInputNumber);
21480     _res = Py_BuildValue("lh",
21481                          _rv,
21482                          outInputNumber);
21483     return _res;
21484 }
21485
21486 static PyObject *Qt_SGSetChannelDeviceInput(PyObject *_self, PyObject *_args)
21487 {
21488     PyObject *_res = NULL;
21489     ComponentResult _rv;
21490     SGChannel c;
21491     short inInputNumber;
21492 #ifndef SGSetChannelDeviceInput
21493     PyMac_PRECHECK(SGSetChannelDeviceInput);
21494 #endif
21495     if (!PyArg_ParseTuple(_args, "O&h",
21496                           CmpInstObj_Convert, &c,
21497                           &inInputNumber))
21498         return NULL;
21499     _rv = SGSetChannelDeviceInput(c,
21500                                   inInputNumber);
21501     _res = Py_BuildValue("l",
21502                          _rv);
21503     return _res;
21504 }
21505
21506 static PyObject *Qt_SGSetChannelSettingsStateChanging(PyObject *_self, PyObject *_args)
21507 {
21508     PyObject *_res = NULL;
21509     ComponentResult _rv;
21510     SGChannel c;
21511     UInt32 inFlags;
21512 #ifndef SGSetChannelSettingsStateChanging
21513     PyMac_PRECHECK(SGSetChannelSettingsStateChanging);
21514 #endif
21515     if (!PyArg_ParseTuple(_args, "O&l",
21516                           CmpInstObj_Convert, &c,
21517                           &inFlags))
21518         return NULL;
21519     _rv = SGSetChannelSettingsStateChanging(c,
21520                                             inFlags);
21521     _res = Py_BuildValue("l",
21522                          _rv);
21523     return _res;
21524 }
21525
21526 static PyObject *Qt_SGInitChannel(PyObject *_self, PyObject *_args)
21527 {
21528     PyObject *_res = NULL;
21529     ComponentResult _rv;
21530     SGChannel c;
21531     SeqGrabComponent owner;
21532 #ifndef SGInitChannel
21533     PyMac_PRECHECK(SGInitChannel);
21534 #endif
21535     if (!PyArg_ParseTuple(_args, "O&O&",
21536                           CmpInstObj_Convert, &c,
21537                           CmpInstObj_Convert, &owner))
21538         return NULL;
21539     _rv = SGInitChannel(c,
21540                         owner);
21541     _res = Py_BuildValue("l",
21542                          _rv);
21543     return _res;
21544 }
21545
21546 static PyObject *Qt_SGWriteSamples(PyObject *_self, PyObject *_args)
21547 {
21548     PyObject *_res = NULL;
21549     ComponentResult _rv;
21550     SGChannel c;
21551     Movie m;
21552     AliasHandle theFile;
21553 #ifndef SGWriteSamples
21554     PyMac_PRECHECK(SGWriteSamples);
21555 #endif
21556     if (!PyArg_ParseTuple(_args, "O&O&O&",
21557                           CmpInstObj_Convert, &c,
21558                           MovieObj_Convert, &m,
21559                           ResObj_Convert, &theFile))
21560         return NULL;
21561     _rv = SGWriteSamples(c,
21562                          m,
21563                          theFile);
21564     _res = Py_BuildValue("l",
21565                          _rv);
21566     return _res;
21567 }
21568
21569 static PyObject *Qt_SGGetDataRate(PyObject *_self, PyObject *_args)
21570 {
21571     PyObject *_res = NULL;
21572     ComponentResult _rv;
21573     SGChannel c;
21574     long bytesPerSecond;
21575 #ifndef SGGetDataRate
21576     PyMac_PRECHECK(SGGetDataRate);
21577 #endif
21578     if (!PyArg_ParseTuple(_args, "O&",
21579                           CmpInstObj_Convert, &c))
21580         return NULL;
21581     _rv = SGGetDataRate(c,
21582                         &bytesPerSecond);
21583     _res = Py_BuildValue("ll",
21584                          _rv,
21585                          bytesPerSecond);
21586     return _res;
21587 }
21588
21589 static PyObject *Qt_SGAlignChannelRect(PyObject *_self, PyObject *_args)
21590 {
21591     PyObject *_res = NULL;
21592     ComponentResult _rv;
21593     SGChannel c;
21594     Rect r;
21595 #ifndef SGAlignChannelRect
21596     PyMac_PRECHECK(SGAlignChannelRect);
21597 #endif
21598     if (!PyArg_ParseTuple(_args, "O&",
21599                           CmpInstObj_Convert, &c))
21600         return NULL;
21601     _rv = SGAlignChannelRect(c,
21602                              &r);
21603     _res = Py_BuildValue("lO&",
21604                          _rv,
21605                          PyMac_BuildRect, &r);
21606     return _res;
21607 }
21608
21609 static PyObject *Qt_SGPanelGetDitl(PyObject *_self, PyObject *_args)
21610 {
21611     PyObject *_res = NULL;
21612     ComponentResult _rv;
21613     SeqGrabComponent s;
21614     Handle ditl;
21615 #ifndef SGPanelGetDitl
21616     PyMac_PRECHECK(SGPanelGetDitl);
21617 #endif
21618     if (!PyArg_ParseTuple(_args, "O&",
21619                           CmpInstObj_Convert, &s))
21620         return NULL;
21621     _rv = SGPanelGetDitl(s,
21622                          &ditl);
21623     _res = Py_BuildValue("lO&",
21624                          _rv,
21625                          ResObj_New, ditl);
21626     return _res;
21627 }
21628
21629 static PyObject *Qt_SGPanelGetTitle(PyObject *_self, PyObject *_args)
21630 {
21631     PyObject *_res = NULL;
21632     ComponentResult _rv;
21633     SeqGrabComponent s;
21634     Str255 title;
21635 #ifndef SGPanelGetTitle
21636     PyMac_PRECHECK(SGPanelGetTitle);
21637 #endif
21638     if (!PyArg_ParseTuple(_args, "O&O&",
21639                           CmpInstObj_Convert, &s,
21640                           PyMac_GetStr255, title))
21641         return NULL;
21642     _rv = SGPanelGetTitle(s,
21643                           title);
21644     _res = Py_BuildValue("l",
21645                          _rv);
21646     return _res;
21647 }
21648
21649 static PyObject *Qt_SGPanelCanRun(PyObject *_self, PyObject *_args)
21650 {
21651     PyObject *_res = NULL;
21652     ComponentResult _rv;
21653     SeqGrabComponent s;
21654     SGChannel c;
21655 #ifndef SGPanelCanRun
21656     PyMac_PRECHECK(SGPanelCanRun);
21657 #endif
21658     if (!PyArg_ParseTuple(_args, "O&O&",
21659                           CmpInstObj_Convert, &s,
21660                           CmpInstObj_Convert, &c))
21661         return NULL;
21662     _rv = SGPanelCanRun(s,
21663                         c);
21664     _res = Py_BuildValue("l",
21665                          _rv);
21666     return _res;
21667 }
21668
21669 static PyObject *Qt_SGPanelInstall(PyObject *_self, PyObject *_args)
21670 {
21671     PyObject *_res = NULL;
21672     ComponentResult _rv;
21673     SeqGrabComponent s;
21674     SGChannel c;
21675     DialogPtr d;
21676     short itemOffset;
21677 #ifndef SGPanelInstall
21678     PyMac_PRECHECK(SGPanelInstall);
21679 #endif
21680     if (!PyArg_ParseTuple(_args, "O&O&O&h",
21681                           CmpInstObj_Convert, &s,
21682                           CmpInstObj_Convert, &c,
21683                           DlgObj_Convert, &d,
21684                           &itemOffset))
21685         return NULL;
21686     _rv = SGPanelInstall(s,
21687                          c,
21688                          d,
21689                          itemOffset);
21690     _res = Py_BuildValue("l",
21691                          _rv);
21692     return _res;
21693 }
21694
21695 static PyObject *Qt_SGPanelEvent(PyObject *_self, PyObject *_args)
21696 {
21697     PyObject *_res = NULL;
21698     ComponentResult _rv;
21699     SeqGrabComponent s;
21700     SGChannel c;
21701     DialogPtr d;
21702     short itemOffset;
21703     EventRecord theEvent;
21704     short itemHit;
21705     Boolean handled;
21706 #ifndef SGPanelEvent
21707     PyMac_PRECHECK(SGPanelEvent);
21708 #endif
21709     if (!PyArg_ParseTuple(_args, "O&O&O&hO&",
21710                           CmpInstObj_Convert, &s,
21711                           CmpInstObj_Convert, &c,
21712                           DlgObj_Convert, &d,
21713                           &itemOffset,
21714                           PyMac_GetEventRecord, &theEvent))
21715         return NULL;
21716     _rv = SGPanelEvent(s,
21717                        c,
21718                        d,
21719                        itemOffset,
21720                        &theEvent,
21721                        &itemHit,
21722                        &handled);
21723     _res = Py_BuildValue("lhb",
21724                          _rv,
21725                          itemHit,
21726                          handled);
21727     return _res;
21728 }
21729
21730 static PyObject *Qt_SGPanelItem(PyObject *_self, PyObject *_args)
21731 {
21732     PyObject *_res = NULL;
21733     ComponentResult _rv;
21734     SeqGrabComponent s;
21735     SGChannel c;
21736     DialogPtr d;
21737     short itemOffset;
21738     short itemNum;
21739 #ifndef SGPanelItem
21740     PyMac_PRECHECK(SGPanelItem);
21741 #endif
21742     if (!PyArg_ParseTuple(_args, "O&O&O&hh",
21743                           CmpInstObj_Convert, &s,
21744                           CmpInstObj_Convert, &c,
21745                           DlgObj_Convert, &d,
21746                           &itemOffset,
21747                           &itemNum))
21748         return NULL;
21749     _rv = SGPanelItem(s,
21750                       c,
21751                       d,
21752                       itemOffset,
21753                       itemNum);
21754     _res = Py_BuildValue("l",
21755                          _rv);
21756     return _res;
21757 }
21758
21759 static PyObject *Qt_SGPanelRemove(PyObject *_self, PyObject *_args)
21760 {
21761     PyObject *_res = NULL;
21762     ComponentResult _rv;
21763     SeqGrabComponent s;
21764     SGChannel c;
21765     DialogPtr d;
21766     short itemOffset;
21767 #ifndef SGPanelRemove
21768     PyMac_PRECHECK(SGPanelRemove);
21769 #endif
21770     if (!PyArg_ParseTuple(_args, "O&O&O&h",
21771                           CmpInstObj_Convert, &s,
21772                           CmpInstObj_Convert, &c,
21773                           DlgObj_Convert, &d,
21774                           &itemOffset))
21775         return NULL;
21776     _rv = SGPanelRemove(s,
21777                         c,
21778                         d,
21779                         itemOffset);
21780     _res = Py_BuildValue("l",
21781                          _rv);
21782     return _res;
21783 }
21784
21785 static PyObject *Qt_SGPanelSetGrabber(PyObject *_self, PyObject *_args)
21786 {
21787     PyObject *_res = NULL;
21788     ComponentResult _rv;
21789     SeqGrabComponent s;
21790     SeqGrabComponent sg;
21791 #ifndef SGPanelSetGrabber
21792     PyMac_PRECHECK(SGPanelSetGrabber);
21793 #endif
21794     if (!PyArg_ParseTuple(_args, "O&O&",
21795                           CmpInstObj_Convert, &s,
21796                           CmpInstObj_Convert, &sg))
21797         return NULL;
21798     _rv = SGPanelSetGrabber(s,
21799                             sg);
21800     _res = Py_BuildValue("l",
21801                          _rv);
21802     return _res;
21803 }
21804
21805 static PyObject *Qt_SGPanelSetResFile(PyObject *_self, PyObject *_args)
21806 {
21807     PyObject *_res = NULL;
21808     ComponentResult _rv;
21809     SeqGrabComponent s;
21810     short resRef;
21811 #ifndef SGPanelSetResFile
21812     PyMac_PRECHECK(SGPanelSetResFile);
21813 #endif
21814     if (!PyArg_ParseTuple(_args, "O&h",
21815                           CmpInstObj_Convert, &s,
21816                           &resRef))
21817         return NULL;
21818     _rv = SGPanelSetResFile(s,
21819                             resRef);
21820     _res = Py_BuildValue("l",
21821                          _rv);
21822     return _res;
21823 }
21824
21825 static PyObject *Qt_SGPanelGetSettings(PyObject *_self, PyObject *_args)
21826 {
21827     PyObject *_res = NULL;
21828     ComponentResult _rv;
21829     SeqGrabComponent s;
21830     SGChannel c;
21831     UserData ud;
21832     long flags;
21833 #ifndef SGPanelGetSettings
21834     PyMac_PRECHECK(SGPanelGetSettings);
21835 #endif
21836     if (!PyArg_ParseTuple(_args, "O&O&l",
21837                           CmpInstObj_Convert, &s,
21838                           CmpInstObj_Convert, &c,
21839                           &flags))
21840         return NULL;
21841     _rv = SGPanelGetSettings(s,
21842                              c,
21843                              &ud,
21844                              flags);
21845     _res = Py_BuildValue("lO&",
21846                          _rv,
21847                          UserDataObj_New, ud);
21848     return _res;
21849 }
21850
21851 static PyObject *Qt_SGPanelSetSettings(PyObject *_self, PyObject *_args)
21852 {
21853     PyObject *_res = NULL;
21854     ComponentResult _rv;
21855     SeqGrabComponent s;
21856     SGChannel c;
21857     UserData ud;
21858     long flags;
21859 #ifndef SGPanelSetSettings
21860     PyMac_PRECHECK(SGPanelSetSettings);
21861 #endif
21862     if (!PyArg_ParseTuple(_args, "O&O&O&l",
21863                           CmpInstObj_Convert, &s,
21864                           CmpInstObj_Convert, &c,
21865                           UserDataObj_Convert, &ud,
21866                           &flags))
21867         return NULL;
21868     _rv = SGPanelSetSettings(s,
21869                              c,
21870                              ud,
21871                              flags);
21872     _res = Py_BuildValue("l",
21873                          _rv);
21874     return _res;
21875 }
21876
21877 static PyObject *Qt_SGPanelValidateInput(PyObject *_self, PyObject *_args)
21878 {
21879     PyObject *_res = NULL;
21880     ComponentResult _rv;
21881     SeqGrabComponent s;
21882     Boolean ok;
21883 #ifndef SGPanelValidateInput
21884     PyMac_PRECHECK(SGPanelValidateInput);
21885 #endif
21886     if (!PyArg_ParseTuple(_args, "O&",
21887                           CmpInstObj_Convert, &s))
21888         return NULL;
21889     _rv = SGPanelValidateInput(s,
21890                                &ok);
21891     _res = Py_BuildValue("lb",
21892                          _rv,
21893                          ok);
21894     return _res;
21895 }
21896
21897 static PyObject *Qt_SGPanelGetDITLForSize(PyObject *_self, PyObject *_args)
21898 {
21899     PyObject *_res = NULL;
21900     ComponentResult _rv;
21901     SeqGrabComponent s;
21902     Handle ditl;
21903     Point requestedSize;
21904 #ifndef SGPanelGetDITLForSize
21905     PyMac_PRECHECK(SGPanelGetDITLForSize);
21906 #endif
21907     if (!PyArg_ParseTuple(_args, "O&",
21908                           CmpInstObj_Convert, &s))
21909         return NULL;
21910     _rv = SGPanelGetDITLForSize(s,
21911                                 &ditl,
21912                                 &requestedSize);
21913     _res = Py_BuildValue("lO&O&",
21914                          _rv,
21915                          ResObj_New, ditl,
21916                          PyMac_BuildPoint, requestedSize);
21917     return _res;
21918 }
21919
21920 static PyObject *Qt_SGGetSrcVideoBounds(PyObject *_self, PyObject *_args)
21921 {
21922     PyObject *_res = NULL;
21923     ComponentResult _rv;
21924     SGChannel c;
21925     Rect r;
21926 #ifndef SGGetSrcVideoBounds
21927     PyMac_PRECHECK(SGGetSrcVideoBounds);
21928 #endif
21929     if (!PyArg_ParseTuple(_args, "O&",
21930                           CmpInstObj_Convert, &c))
21931         return NULL;
21932     _rv = SGGetSrcVideoBounds(c,
21933                               &r);
21934     _res = Py_BuildValue("lO&",
21935                          _rv,
21936                          PyMac_BuildRect, &r);
21937     return _res;
21938 }
21939
21940 static PyObject *Qt_SGSetVideoRect(PyObject *_self, PyObject *_args)
21941 {
21942     PyObject *_res = NULL;
21943     ComponentResult _rv;
21944     SGChannel c;
21945     Rect r;
21946 #ifndef SGSetVideoRect
21947     PyMac_PRECHECK(SGSetVideoRect);
21948 #endif
21949     if (!PyArg_ParseTuple(_args, "O&O&",
21950                           CmpInstObj_Convert, &c,
21951                           PyMac_GetRect, &r))
21952         return NULL;
21953     _rv = SGSetVideoRect(c,
21954                          &r);
21955     _res = Py_BuildValue("l",
21956                          _rv);
21957     return _res;
21958 }
21959
21960 static PyObject *Qt_SGGetVideoRect(PyObject *_self, PyObject *_args)
21961 {
21962     PyObject *_res = NULL;
21963     ComponentResult _rv;
21964     SGChannel c;
21965     Rect r;
21966 #ifndef SGGetVideoRect
21967     PyMac_PRECHECK(SGGetVideoRect);
21968 #endif
21969     if (!PyArg_ParseTuple(_args, "O&",
21970                           CmpInstObj_Convert, &c))
21971         return NULL;
21972     _rv = SGGetVideoRect(c,
21973                          &r);
21974     _res = Py_BuildValue("lO&",
21975                          _rv,
21976                          PyMac_BuildRect, &r);
21977     return _res;
21978 }
21979
21980 static PyObject *Qt_SGGetVideoCompressorType(PyObject *_self, PyObject *_args)
21981 {
21982     PyObject *_res = NULL;
21983     ComponentResult _rv;
21984     SGChannel c;
21985     OSType compressorType;
21986 #ifndef SGGetVideoCompressorType
21987     PyMac_PRECHECK(SGGetVideoCompressorType);
21988 #endif
21989     if (!PyArg_ParseTuple(_args, "O&",
21990                           CmpInstObj_Convert, &c))
21991         return NULL;
21992     _rv = SGGetVideoCompressorType(c,
21993                                    &compressorType);
21994     _res = Py_BuildValue("lO&",
21995                          _rv,
21996                          PyMac_BuildOSType, compressorType);
21997     return _res;
21998 }
21999
22000 static PyObject *Qt_SGSetVideoCompressorType(PyObject *_self, PyObject *_args)
22001 {
22002     PyObject *_res = NULL;
22003     ComponentResult _rv;
22004     SGChannel c;
22005     OSType compressorType;
22006 #ifndef SGSetVideoCompressorType
22007     PyMac_PRECHECK(SGSetVideoCompressorType);
22008 #endif
22009     if (!PyArg_ParseTuple(_args, "O&O&",
22010                           CmpInstObj_Convert, &c,
22011                           PyMac_GetOSType, &compressorType))
22012         return NULL;
22013     _rv = SGSetVideoCompressorType(c,
22014                                    compressorType);
22015     _res = Py_BuildValue("l",
22016                          _rv);
22017     return _res;
22018 }
22019
22020 static PyObject *Qt_SGSetVideoCompressor(PyObject *_self, PyObject *_args)
22021 {
22022     PyObject *_res = NULL;
22023     ComponentResult _rv;
22024     SGChannel c;
22025     short depth;
22026     CompressorComponent compressor;
22027     CodecQ spatialQuality;
22028     CodecQ temporalQuality;
22029     long keyFrameRate;
22030 #ifndef SGSetVideoCompressor
22031     PyMac_PRECHECK(SGSetVideoCompressor);
22032 #endif
22033     if (!PyArg_ParseTuple(_args, "O&hO&lll",
22034                           CmpInstObj_Convert, &c,
22035                           &depth,
22036                           CmpObj_Convert, &compressor,
22037                           &spatialQuality,
22038                           &temporalQuality,
22039                           &keyFrameRate))
22040         return NULL;
22041     _rv = SGSetVideoCompressor(c,
22042                                depth,
22043                                compressor,
22044                                spatialQuality,
22045                                temporalQuality,
22046                                keyFrameRate);
22047     _res = Py_BuildValue("l",
22048                          _rv);
22049     return _res;
22050 }
22051
22052 static PyObject *Qt_SGGetVideoCompressor(PyObject *_self, PyObject *_args)
22053 {
22054     PyObject *_res = NULL;
22055     ComponentResult _rv;
22056     SGChannel c;
22057     short depth;
22058     CompressorComponent compressor;
22059     CodecQ spatialQuality;
22060     CodecQ temporalQuality;
22061     long keyFrameRate;
22062 #ifndef SGGetVideoCompressor
22063     PyMac_PRECHECK(SGGetVideoCompressor);
22064 #endif
22065     if (!PyArg_ParseTuple(_args, "O&",
22066                           CmpInstObj_Convert, &c))
22067         return NULL;
22068     _rv = SGGetVideoCompressor(c,
22069                                &depth,
22070                                &compressor,
22071                                &spatialQuality,
22072                                &temporalQuality,
22073                                &keyFrameRate);
22074     _res = Py_BuildValue("lhO&lll",
22075                          _rv,
22076                          depth,
22077                          CmpObj_New, compressor,
22078                          spatialQuality,
22079                          temporalQuality,
22080                          keyFrameRate);
22081     return _res;
22082 }
22083
22084 static PyObject *Qt_SGGetVideoDigitizerComponent(PyObject *_self, PyObject *_args)
22085 {
22086     PyObject *_res = NULL;
22087     ComponentInstance _rv;
22088     SGChannel c;
22089 #ifndef SGGetVideoDigitizerComponent
22090     PyMac_PRECHECK(SGGetVideoDigitizerComponent);
22091 #endif
22092     if (!PyArg_ParseTuple(_args, "O&",
22093                           CmpInstObj_Convert, &c))
22094         return NULL;
22095     _rv = SGGetVideoDigitizerComponent(c);
22096     _res = Py_BuildValue("O&",
22097                          CmpInstObj_New, _rv);
22098     return _res;
22099 }
22100
22101 static PyObject *Qt_SGSetVideoDigitizerComponent(PyObject *_self, PyObject *_args)
22102 {
22103     PyObject *_res = NULL;
22104     ComponentResult _rv;
22105     SGChannel c;
22106     ComponentInstance vdig;
22107 #ifndef SGSetVideoDigitizerComponent
22108     PyMac_PRECHECK(SGSetVideoDigitizerComponent);
22109 #endif
22110     if (!PyArg_ParseTuple(_args, "O&O&",
22111                           CmpInstObj_Convert, &c,
22112                           CmpInstObj_Convert, &vdig))
22113         return NULL;
22114     _rv = SGSetVideoDigitizerComponent(c,
22115                                        vdig);
22116     _res = Py_BuildValue("l",
22117                          _rv);
22118     return _res;
22119 }
22120
22121 static PyObject *Qt_SGVideoDigitizerChanged(PyObject *_self, PyObject *_args)
22122 {
22123     PyObject *_res = NULL;
22124     ComponentResult _rv;
22125     SGChannel c;
22126 #ifndef SGVideoDigitizerChanged
22127     PyMac_PRECHECK(SGVideoDigitizerChanged);
22128 #endif
22129     if (!PyArg_ParseTuple(_args, "O&",
22130                           CmpInstObj_Convert, &c))
22131         return NULL;
22132     _rv = SGVideoDigitizerChanged(c);
22133     _res = Py_BuildValue("l",
22134                          _rv);
22135     return _res;
22136 }
22137
22138 static PyObject *Qt_SGGrabFrame(PyObject *_self, PyObject *_args)
22139 {
22140     PyObject *_res = NULL;
22141     ComponentResult _rv;
22142     SGChannel c;
22143     short bufferNum;
22144 #ifndef SGGrabFrame
22145     PyMac_PRECHECK(SGGrabFrame);
22146 #endif
22147     if (!PyArg_ParseTuple(_args, "O&h",
22148                           CmpInstObj_Convert, &c,
22149                           &bufferNum))
22150         return NULL;
22151     _rv = SGGrabFrame(c,
22152                       bufferNum);
22153     _res = Py_BuildValue("l",
22154                          _rv);
22155     return _res;
22156 }
22157
22158 static PyObject *Qt_SGGrabFrameComplete(PyObject *_self, PyObject *_args)
22159 {
22160     PyObject *_res = NULL;
22161     ComponentResult _rv;
22162     SGChannel c;
22163     short bufferNum;
22164     Boolean done;
22165 #ifndef SGGrabFrameComplete
22166     PyMac_PRECHECK(SGGrabFrameComplete);
22167 #endif
22168     if (!PyArg_ParseTuple(_args, "O&h",
22169                           CmpInstObj_Convert, &c,
22170                           &bufferNum))
22171         return NULL;
22172     _rv = SGGrabFrameComplete(c,
22173                               bufferNum,
22174                               &done);
22175     _res = Py_BuildValue("lb",
22176                          _rv,
22177                          done);
22178     return _res;
22179 }
22180
22181 static PyObject *Qt_SGCompressFrame(PyObject *_self, PyObject *_args)
22182 {
22183     PyObject *_res = NULL;
22184     ComponentResult _rv;
22185     SGChannel c;
22186     short bufferNum;
22187 #ifndef SGCompressFrame
22188     PyMac_PRECHECK(SGCompressFrame);
22189 #endif
22190     if (!PyArg_ParseTuple(_args, "O&h",
22191                           CmpInstObj_Convert, &c,
22192                           &bufferNum))
22193         return NULL;
22194     _rv = SGCompressFrame(c,
22195                           bufferNum);
22196     _res = Py_BuildValue("l",
22197                          _rv);
22198     return _res;
22199 }
22200
22201 static PyObject *Qt_SGSetCompressBuffer(PyObject *_self, PyObject *_args)
22202 {
22203     PyObject *_res = NULL;
22204     ComponentResult _rv;
22205     SGChannel c;
22206     short depth;
22207     Rect compressSize;
22208 #ifndef SGSetCompressBuffer
22209     PyMac_PRECHECK(SGSetCompressBuffer);
22210 #endif
22211     if (!PyArg_ParseTuple(_args, "O&hO&",
22212                           CmpInstObj_Convert, &c,
22213                           &depth,
22214                           PyMac_GetRect, &compressSize))
22215         return NULL;
22216     _rv = SGSetCompressBuffer(c,
22217                               depth,
22218                               &compressSize);
22219     _res = Py_BuildValue("l",
22220                          _rv);
22221     return _res;
22222 }
22223
22224 static PyObject *Qt_SGGetCompressBuffer(PyObject *_self, PyObject *_args)
22225 {
22226     PyObject *_res = NULL;
22227     ComponentResult _rv;
22228     SGChannel c;
22229     short depth;
22230     Rect compressSize;
22231 #ifndef SGGetCompressBuffer
22232     PyMac_PRECHECK(SGGetCompressBuffer);
22233 #endif
22234     if (!PyArg_ParseTuple(_args, "O&",
22235                           CmpInstObj_Convert, &c))
22236         return NULL;
22237     _rv = SGGetCompressBuffer(c,
22238                               &depth,
22239                               &compressSize);
22240     _res = Py_BuildValue("lhO&",
22241                          _rv,
22242                          depth,
22243                          PyMac_BuildRect, &compressSize);
22244     return _res;
22245 }
22246
22247 static PyObject *Qt_SGGetBufferInfo(PyObject *_self, PyObject *_args)
22248 {
22249     PyObject *_res = NULL;
22250     ComponentResult _rv;
22251     SGChannel c;
22252     short bufferNum;
22253     PixMapHandle bufferPM;
22254     Rect bufferRect;
22255     GWorldPtr compressBuffer;
22256     Rect compressBufferRect;
22257 #ifndef SGGetBufferInfo
22258     PyMac_PRECHECK(SGGetBufferInfo);
22259 #endif
22260     if (!PyArg_ParseTuple(_args, "O&h",
22261                           CmpInstObj_Convert, &c,
22262                           &bufferNum))
22263         return NULL;
22264     _rv = SGGetBufferInfo(c,
22265                           bufferNum,
22266                           &bufferPM,
22267                           &bufferRect,
22268                           &compressBuffer,
22269                           &compressBufferRect);
22270     _res = Py_BuildValue("lO&O&O&O&",
22271                          _rv,
22272                          ResObj_New, bufferPM,
22273                          PyMac_BuildRect, &bufferRect,
22274                          GWorldObj_New, compressBuffer,
22275                          PyMac_BuildRect, &compressBufferRect);
22276     return _res;
22277 }
22278
22279 static PyObject *Qt_SGSetUseScreenBuffer(PyObject *_self, PyObject *_args)
22280 {
22281     PyObject *_res = NULL;
22282     ComponentResult _rv;
22283     SGChannel c;
22284     Boolean useScreenBuffer;
22285 #ifndef SGSetUseScreenBuffer
22286     PyMac_PRECHECK(SGSetUseScreenBuffer);
22287 #endif
22288     if (!PyArg_ParseTuple(_args, "O&b",
22289                           CmpInstObj_Convert, &c,
22290                           &useScreenBuffer))
22291         return NULL;
22292     _rv = SGSetUseScreenBuffer(c,
22293                                useScreenBuffer);
22294     _res = Py_BuildValue("l",
22295                          _rv);
22296     return _res;
22297 }
22298
22299 static PyObject *Qt_SGGetUseScreenBuffer(PyObject *_self, PyObject *_args)
22300 {
22301     PyObject *_res = NULL;
22302     ComponentResult _rv;
22303     SGChannel c;
22304     Boolean useScreenBuffer;
22305 #ifndef SGGetUseScreenBuffer
22306     PyMac_PRECHECK(SGGetUseScreenBuffer);
22307 #endif
22308     if (!PyArg_ParseTuple(_args, "O&",
22309                           CmpInstObj_Convert, &c))
22310         return NULL;
22311     _rv = SGGetUseScreenBuffer(c,
22312                                &useScreenBuffer);
22313     _res = Py_BuildValue("lb",
22314                          _rv,
22315                          useScreenBuffer);
22316     return _res;
22317 }
22318
22319 static PyObject *Qt_SGSetFrameRate(PyObject *_self, PyObject *_args)
22320 {
22321     PyObject *_res = NULL;
22322     ComponentResult _rv;
22323     SGChannel c;
22324     Fixed frameRate;
22325 #ifndef SGSetFrameRate
22326     PyMac_PRECHECK(SGSetFrameRate);
22327 #endif
22328     if (!PyArg_ParseTuple(_args, "O&O&",
22329                           CmpInstObj_Convert, &c,
22330                           PyMac_GetFixed, &frameRate))
22331         return NULL;
22332     _rv = SGSetFrameRate(c,
22333                          frameRate);
22334     _res = Py_BuildValue("l",
22335                          _rv);
22336     return _res;
22337 }
22338
22339 static PyObject *Qt_SGGetFrameRate(PyObject *_self, PyObject *_args)
22340 {
22341     PyObject *_res = NULL;
22342     ComponentResult _rv;
22343     SGChannel c;
22344     Fixed frameRate;
22345 #ifndef SGGetFrameRate
22346     PyMac_PRECHECK(SGGetFrameRate);
22347 #endif
22348     if (!PyArg_ParseTuple(_args, "O&",
22349                           CmpInstObj_Convert, &c))
22350         return NULL;
22351     _rv = SGGetFrameRate(c,
22352                          &frameRate);
22353     _res = Py_BuildValue("lO&",
22354                          _rv,
22355                          PyMac_BuildFixed, frameRate);
22356     return _res;
22357 }
22358
22359 static PyObject *Qt_SGSetPreferredPacketSize(PyObject *_self, PyObject *_args)
22360 {
22361     PyObject *_res = NULL;
22362     ComponentResult _rv;
22363     SGChannel c;
22364     long preferredPacketSizeInBytes;
22365 #ifndef SGSetPreferredPacketSize
22366     PyMac_PRECHECK(SGSetPreferredPacketSize);
22367 #endif
22368     if (!PyArg_ParseTuple(_args, "O&l",
22369                           CmpInstObj_Convert, &c,
22370                           &preferredPacketSizeInBytes))
22371         return NULL;
22372     _rv = SGSetPreferredPacketSize(c,
22373                                    preferredPacketSizeInBytes);
22374     _res = Py_BuildValue("l",
22375                          _rv);
22376     return _res;
22377 }
22378
22379 static PyObject *Qt_SGGetPreferredPacketSize(PyObject *_self, PyObject *_args)
22380 {
22381     PyObject *_res = NULL;
22382     ComponentResult _rv;
22383     SGChannel c;
22384     long preferredPacketSizeInBytes;
22385 #ifndef SGGetPreferredPacketSize
22386     PyMac_PRECHECK(SGGetPreferredPacketSize);
22387 #endif
22388     if (!PyArg_ParseTuple(_args, "O&",
22389                           CmpInstObj_Convert, &c))
22390         return NULL;
22391     _rv = SGGetPreferredPacketSize(c,
22392                                    &preferredPacketSizeInBytes);
22393     _res = Py_BuildValue("ll",
22394                          _rv,
22395                          preferredPacketSizeInBytes);
22396     return _res;
22397 }
22398
22399 static PyObject *Qt_SGSetUserVideoCompressorList(PyObject *_self, PyObject *_args)
22400 {
22401     PyObject *_res = NULL;
22402     ComponentResult _rv;
22403     SGChannel c;
22404     Handle compressorTypes;
22405 #ifndef SGSetUserVideoCompressorList
22406     PyMac_PRECHECK(SGSetUserVideoCompressorList);
22407 #endif
22408     if (!PyArg_ParseTuple(_args, "O&O&",
22409                           CmpInstObj_Convert, &c,
22410                           ResObj_Convert, &compressorTypes))
22411         return NULL;
22412     _rv = SGSetUserVideoCompressorList(c,
22413                                        compressorTypes);
22414     _res = Py_BuildValue("l",
22415                          _rv);
22416     return _res;
22417 }
22418
22419 static PyObject *Qt_SGGetUserVideoCompressorList(PyObject *_self, PyObject *_args)
22420 {
22421     PyObject *_res = NULL;
22422     ComponentResult _rv;
22423     SGChannel c;
22424     Handle compressorTypes;
22425 #ifndef SGGetUserVideoCompressorList
22426     PyMac_PRECHECK(SGGetUserVideoCompressorList);
22427 #endif
22428     if (!PyArg_ParseTuple(_args, "O&",
22429                           CmpInstObj_Convert, &c))
22430         return NULL;
22431     _rv = SGGetUserVideoCompressorList(c,
22432                                        &compressorTypes);
22433     _res = Py_BuildValue("lO&",
22434                          _rv,
22435                          ResObj_New, compressorTypes);
22436     return _res;
22437 }
22438
22439 static PyObject *Qt_SGSetSoundInputDriver(PyObject *_self, PyObject *_args)
22440 {
22441     PyObject *_res = NULL;
22442     ComponentResult _rv;
22443     SGChannel c;
22444     Str255 driverName;
22445 #ifndef SGSetSoundInputDriver
22446     PyMac_PRECHECK(SGSetSoundInputDriver);
22447 #endif
22448     if (!PyArg_ParseTuple(_args, "O&O&",
22449                           CmpInstObj_Convert, &c,
22450                           PyMac_GetStr255, driverName))
22451         return NULL;
22452     _rv = SGSetSoundInputDriver(c,
22453                                 driverName);
22454     _res = Py_BuildValue("l",
22455                          _rv);
22456     return _res;
22457 }
22458
22459 static PyObject *Qt_SGGetSoundInputDriver(PyObject *_self, PyObject *_args)
22460 {
22461     PyObject *_res = NULL;
22462     long _rv;
22463     SGChannel c;
22464 #ifndef SGGetSoundInputDriver
22465     PyMac_PRECHECK(SGGetSoundInputDriver);
22466 #endif
22467     if (!PyArg_ParseTuple(_args, "O&",
22468                           CmpInstObj_Convert, &c))
22469         return NULL;
22470     _rv = SGGetSoundInputDriver(c);
22471     _res = Py_BuildValue("l",
22472                          _rv);
22473     return _res;
22474 }
22475
22476 static PyObject *Qt_SGSoundInputDriverChanged(PyObject *_self, PyObject *_args)
22477 {
22478     PyObject *_res = NULL;
22479     ComponentResult _rv;
22480     SGChannel c;
22481 #ifndef SGSoundInputDriverChanged
22482     PyMac_PRECHECK(SGSoundInputDriverChanged);
22483 #endif
22484     if (!PyArg_ParseTuple(_args, "O&",
22485                           CmpInstObj_Convert, &c))
22486         return NULL;
22487     _rv = SGSoundInputDriverChanged(c);
22488     _res = Py_BuildValue("l",
22489                          _rv);
22490     return _res;
22491 }
22492
22493 static PyObject *Qt_SGSetSoundRecordChunkSize(PyObject *_self, PyObject *_args)
22494 {
22495     PyObject *_res = NULL;
22496     ComponentResult _rv;
22497     SGChannel c;
22498     long seconds;
22499 #ifndef SGSetSoundRecordChunkSize
22500     PyMac_PRECHECK(SGSetSoundRecordChunkSize);
22501 #endif
22502     if (!PyArg_ParseTuple(_args, "O&l",
22503                           CmpInstObj_Convert, &c,
22504                           &seconds))
22505         return NULL;
22506     _rv = SGSetSoundRecordChunkSize(c,
22507                                     seconds);
22508     _res = Py_BuildValue("l",
22509                          _rv);
22510     return _res;
22511 }
22512
22513 static PyObject *Qt_SGGetSoundRecordChunkSize(PyObject *_self, PyObject *_args)
22514 {
22515     PyObject *_res = NULL;
22516     long _rv;
22517     SGChannel c;
22518 #ifndef SGGetSoundRecordChunkSize
22519     PyMac_PRECHECK(SGGetSoundRecordChunkSize);
22520 #endif
22521     if (!PyArg_ParseTuple(_args, "O&",
22522                           CmpInstObj_Convert, &c))
22523         return NULL;
22524     _rv = SGGetSoundRecordChunkSize(c);
22525     _res = Py_BuildValue("l",
22526                          _rv);
22527     return _res;
22528 }
22529
22530 static PyObject *Qt_SGSetSoundInputRate(PyObject *_self, PyObject *_args)
22531 {
22532     PyObject *_res = NULL;
22533     ComponentResult _rv;
22534     SGChannel c;
22535     Fixed rate;
22536 #ifndef SGSetSoundInputRate
22537     PyMac_PRECHECK(SGSetSoundInputRate);
22538 #endif
22539     if (!PyArg_ParseTuple(_args, "O&O&",
22540                           CmpInstObj_Convert, &c,
22541                           PyMac_GetFixed, &rate))
22542         return NULL;
22543     _rv = SGSetSoundInputRate(c,
22544                               rate);
22545     _res = Py_BuildValue("l",
22546                          _rv);
22547     return _res;
22548 }
22549
22550 static PyObject *Qt_SGGetSoundInputRate(PyObject *_self, PyObject *_args)
22551 {
22552     PyObject *_res = NULL;
22553     Fixed _rv;
22554     SGChannel c;
22555 #ifndef SGGetSoundInputRate
22556     PyMac_PRECHECK(SGGetSoundInputRate);
22557 #endif
22558     if (!PyArg_ParseTuple(_args, "O&",
22559                           CmpInstObj_Convert, &c))
22560         return NULL;
22561     _rv = SGGetSoundInputRate(c);
22562     _res = Py_BuildValue("O&",
22563                          PyMac_BuildFixed, _rv);
22564     return _res;
22565 }
22566
22567 static PyObject *Qt_SGSetSoundInputParameters(PyObject *_self, PyObject *_args)
22568 {
22569     PyObject *_res = NULL;
22570     ComponentResult _rv;
22571     SGChannel c;
22572     short sampleSize;
22573     short numChannels;
22574     OSType compressionType;
22575 #ifndef SGSetSoundInputParameters
22576     PyMac_PRECHECK(SGSetSoundInputParameters);
22577 #endif
22578     if (!PyArg_ParseTuple(_args, "O&hhO&",
22579                           CmpInstObj_Convert, &c,
22580                           &sampleSize,
22581                           &numChannels,
22582                           PyMac_GetOSType, &compressionType))
22583         return NULL;
22584     _rv = SGSetSoundInputParameters(c,
22585                                     sampleSize,
22586                                     numChannels,
22587                                     compressionType);
22588     _res = Py_BuildValue("l",
22589                          _rv);
22590     return _res;
22591 }
22592
22593 static PyObject *Qt_SGGetSoundInputParameters(PyObject *_self, PyObject *_args)
22594 {
22595     PyObject *_res = NULL;
22596     ComponentResult _rv;
22597     SGChannel c;
22598     short sampleSize;
22599     short numChannels;
22600     OSType compressionType;
22601 #ifndef SGGetSoundInputParameters
22602     PyMac_PRECHECK(SGGetSoundInputParameters);
22603 #endif
22604     if (!PyArg_ParseTuple(_args, "O&",
22605                           CmpInstObj_Convert, &c))
22606         return NULL;
22607     _rv = SGGetSoundInputParameters(c,
22608                                     &sampleSize,
22609                                     &numChannels,
22610                                     &compressionType);
22611     _res = Py_BuildValue("lhhO&",
22612                          _rv,
22613                          sampleSize,
22614                          numChannels,
22615                          PyMac_BuildOSType, compressionType);
22616     return _res;
22617 }
22618
22619 static PyObject *Qt_SGSetAdditionalSoundRates(PyObject *_self, PyObject *_args)
22620 {
22621     PyObject *_res = NULL;
22622     ComponentResult _rv;
22623     SGChannel c;
22624     Handle rates;
22625 #ifndef SGSetAdditionalSoundRates
22626     PyMac_PRECHECK(SGSetAdditionalSoundRates);
22627 #endif
22628     if (!PyArg_ParseTuple(_args, "O&O&",
22629                           CmpInstObj_Convert, &c,
22630                           ResObj_Convert, &rates))
22631         return NULL;
22632     _rv = SGSetAdditionalSoundRates(c,
22633                                     rates);
22634     _res = Py_BuildValue("l",
22635                          _rv);
22636     return _res;
22637 }
22638
22639 static PyObject *Qt_SGGetAdditionalSoundRates(PyObject *_self, PyObject *_args)
22640 {
22641     PyObject *_res = NULL;
22642     ComponentResult _rv;
22643     SGChannel c;
22644     Handle rates;
22645 #ifndef SGGetAdditionalSoundRates
22646     PyMac_PRECHECK(SGGetAdditionalSoundRates);
22647 #endif
22648     if (!PyArg_ParseTuple(_args, "O&",
22649                           CmpInstObj_Convert, &c))
22650         return NULL;
22651     _rv = SGGetAdditionalSoundRates(c,
22652                                     &rates);
22653     _res = Py_BuildValue("lO&",
22654                          _rv,
22655                          ResObj_New, rates);
22656     return _res;
22657 }
22658
22659 static PyObject *Qt_SGSetFontName(PyObject *_self, PyObject *_args)
22660 {
22661     PyObject *_res = NULL;
22662     ComponentResult _rv;
22663     SGChannel c;
22664     StringPtr pstr;
22665 #ifndef SGSetFontName
22666     PyMac_PRECHECK(SGSetFontName);
22667 #endif
22668     if (!PyArg_ParseTuple(_args, "O&s",
22669                           CmpInstObj_Convert, &c,
22670                           &pstr))
22671         return NULL;
22672     _rv = SGSetFontName(c,
22673                         pstr);
22674     _res = Py_BuildValue("l",
22675                          _rv);
22676     return _res;
22677 }
22678
22679 static PyObject *Qt_SGSetFontSize(PyObject *_self, PyObject *_args)
22680 {
22681     PyObject *_res = NULL;
22682     ComponentResult _rv;
22683     SGChannel c;
22684     short fontSize;
22685 #ifndef SGSetFontSize
22686     PyMac_PRECHECK(SGSetFontSize);
22687 #endif
22688     if (!PyArg_ParseTuple(_args, "O&h",
22689                           CmpInstObj_Convert, &c,
22690                           &fontSize))
22691         return NULL;
22692     _rv = SGSetFontSize(c,
22693                         fontSize);
22694     _res = Py_BuildValue("l",
22695                          _rv);
22696     return _res;
22697 }
22698
22699 static PyObject *Qt_SGSetTextForeColor(PyObject *_self, PyObject *_args)
22700 {
22701     PyObject *_res = NULL;
22702     ComponentResult _rv;
22703     SGChannel c;
22704     RGBColor theColor;
22705 #ifndef SGSetTextForeColor
22706     PyMac_PRECHECK(SGSetTextForeColor);
22707 #endif
22708     if (!PyArg_ParseTuple(_args, "O&",
22709                           CmpInstObj_Convert, &c))
22710         return NULL;
22711     _rv = SGSetTextForeColor(c,
22712                              &theColor);
22713     _res = Py_BuildValue("lO&",
22714                          _rv,
22715                          QdRGB_New, &theColor);
22716     return _res;
22717 }
22718
22719 static PyObject *Qt_SGSetTextBackColor(PyObject *_self, PyObject *_args)
22720 {
22721     PyObject *_res = NULL;
22722     ComponentResult _rv;
22723     SGChannel c;
22724     RGBColor theColor;
22725 #ifndef SGSetTextBackColor
22726     PyMac_PRECHECK(SGSetTextBackColor);
22727 #endif
22728     if (!PyArg_ParseTuple(_args, "O&",
22729                           CmpInstObj_Convert, &c))
22730         return NULL;
22731     _rv = SGSetTextBackColor(c,
22732                              &theColor);
22733     _res = Py_BuildValue("lO&",
22734                          _rv,
22735                          QdRGB_New, &theColor);
22736     return _res;
22737 }
22738
22739 static PyObject *Qt_SGSetJustification(PyObject *_self, PyObject *_args)
22740 {
22741     PyObject *_res = NULL;
22742     ComponentResult _rv;
22743     SGChannel c;
22744     short just;
22745 #ifndef SGSetJustification
22746     PyMac_PRECHECK(SGSetJustification);
22747 #endif
22748     if (!PyArg_ParseTuple(_args, "O&h",
22749                           CmpInstObj_Convert, &c,
22750                           &just))
22751         return NULL;
22752     _rv = SGSetJustification(c,
22753                              just);
22754     _res = Py_BuildValue("l",
22755                          _rv);
22756     return _res;
22757 }
22758
22759 static PyObject *Qt_SGGetTextReturnToSpaceValue(PyObject *_self, PyObject *_args)
22760 {
22761     PyObject *_res = NULL;
22762     ComponentResult _rv;
22763     SGChannel c;
22764     short rettospace;
22765 #ifndef SGGetTextReturnToSpaceValue
22766     PyMac_PRECHECK(SGGetTextReturnToSpaceValue);
22767 #endif
22768     if (!PyArg_ParseTuple(_args, "O&",
22769                           CmpInstObj_Convert, &c))
22770         return NULL;
22771     _rv = SGGetTextReturnToSpaceValue(c,
22772                                       &rettospace);
22773     _res = Py_BuildValue("lh",
22774                          _rv,
22775                          rettospace);
22776     return _res;
22777 }
22778
22779 static PyObject *Qt_SGSetTextReturnToSpaceValue(PyObject *_self, PyObject *_args)
22780 {
22781     PyObject *_res = NULL;
22782     ComponentResult _rv;
22783     SGChannel c;
22784     short rettospace;
22785 #ifndef SGSetTextReturnToSpaceValue
22786     PyMac_PRECHECK(SGSetTextReturnToSpaceValue);
22787 #endif
22788     if (!PyArg_ParseTuple(_args, "O&h",
22789                           CmpInstObj_Convert, &c,
22790                           &rettospace))
22791         return NULL;
22792     _rv = SGSetTextReturnToSpaceValue(c,
22793                                       rettospace);
22794     _res = Py_BuildValue("l",
22795                          _rv);
22796     return _res;
22797 }
22798
22799 static PyObject *Qt_QTVideoOutputGetCurrentClientName(PyObject *_self, PyObject *_args)
22800 {
22801     PyObject *_res = NULL;
22802     ComponentResult _rv;
22803     QTVideoOutputComponent vo;
22804     Str255 str;
22805 #ifndef QTVideoOutputGetCurrentClientName
22806     PyMac_PRECHECK(QTVideoOutputGetCurrentClientName);
22807 #endif
22808     if (!PyArg_ParseTuple(_args, "O&O&",
22809                           CmpInstObj_Convert, &vo,
22810                           PyMac_GetStr255, str))
22811         return NULL;
22812     _rv = QTVideoOutputGetCurrentClientName(vo,
22813                                             str);
22814     _res = Py_BuildValue("l",
22815                          _rv);
22816     return _res;
22817 }
22818
22819 static PyObject *Qt_QTVideoOutputSetClientName(PyObject *_self, PyObject *_args)
22820 {
22821     PyObject *_res = NULL;
22822     ComponentResult _rv;
22823     QTVideoOutputComponent vo;
22824     Str255 str;
22825 #ifndef QTVideoOutputSetClientName
22826     PyMac_PRECHECK(QTVideoOutputSetClientName);
22827 #endif
22828     if (!PyArg_ParseTuple(_args, "O&O&",
22829                           CmpInstObj_Convert, &vo,
22830                           PyMac_GetStr255, str))
22831         return NULL;
22832     _rv = QTVideoOutputSetClientName(vo,
22833                                      str);
22834     _res = Py_BuildValue("l",
22835                          _rv);
22836     return _res;
22837 }
22838
22839 static PyObject *Qt_QTVideoOutputGetClientName(PyObject *_self, PyObject *_args)
22840 {
22841     PyObject *_res = NULL;
22842     ComponentResult _rv;
22843     QTVideoOutputComponent vo;
22844     Str255 str;
22845 #ifndef QTVideoOutputGetClientName
22846     PyMac_PRECHECK(QTVideoOutputGetClientName);
22847 #endif
22848     if (!PyArg_ParseTuple(_args, "O&O&",
22849                           CmpInstObj_Convert, &vo,
22850                           PyMac_GetStr255, str))
22851         return NULL;
22852     _rv = QTVideoOutputGetClientName(vo,
22853                                      str);
22854     _res = Py_BuildValue("l",
22855                          _rv);
22856     return _res;
22857 }
22858
22859 static PyObject *Qt_QTVideoOutputBegin(PyObject *_self, PyObject *_args)
22860 {
22861     PyObject *_res = NULL;
22862     ComponentResult _rv;
22863     QTVideoOutputComponent vo;
22864 #ifndef QTVideoOutputBegin
22865     PyMac_PRECHECK(QTVideoOutputBegin);
22866 #endif
22867     if (!PyArg_ParseTuple(_args, "O&",
22868                           CmpInstObj_Convert, &vo))
22869         return NULL;
22870     _rv = QTVideoOutputBegin(vo);
22871     _res = Py_BuildValue("l",
22872                          _rv);
22873     return _res;
22874 }
22875
22876 static PyObject *Qt_QTVideoOutputEnd(PyObject *_self, PyObject *_args)
22877 {
22878     PyObject *_res = NULL;
22879     ComponentResult _rv;
22880     QTVideoOutputComponent vo;
22881 #ifndef QTVideoOutputEnd
22882     PyMac_PRECHECK(QTVideoOutputEnd);
22883 #endif
22884     if (!PyArg_ParseTuple(_args, "O&",
22885                           CmpInstObj_Convert, &vo))
22886         return NULL;
22887     _rv = QTVideoOutputEnd(vo);
22888     _res = Py_BuildValue("l",
22889                          _rv);
22890     return _res;
22891 }
22892
22893 static PyObject *Qt_QTVideoOutputSetDisplayMode(PyObject *_self, PyObject *_args)
22894 {
22895     PyObject *_res = NULL;
22896     ComponentResult _rv;
22897     QTVideoOutputComponent vo;
22898     long displayModeID;
22899 #ifndef QTVideoOutputSetDisplayMode
22900     PyMac_PRECHECK(QTVideoOutputSetDisplayMode);
22901 #endif
22902     if (!PyArg_ParseTuple(_args, "O&l",
22903                           CmpInstObj_Convert, &vo,
22904                           &displayModeID))
22905         return NULL;
22906     _rv = QTVideoOutputSetDisplayMode(vo,
22907                                       displayModeID);
22908     _res = Py_BuildValue("l",
22909                          _rv);
22910     return _res;
22911 }
22912
22913 static PyObject *Qt_QTVideoOutputGetDisplayMode(PyObject *_self, PyObject *_args)
22914 {
22915     PyObject *_res = NULL;
22916     ComponentResult _rv;
22917     QTVideoOutputComponent vo;
22918     long displayModeID;
22919 #ifndef QTVideoOutputGetDisplayMode
22920     PyMac_PRECHECK(QTVideoOutputGetDisplayMode);
22921 #endif
22922     if (!PyArg_ParseTuple(_args, "O&",
22923                           CmpInstObj_Convert, &vo))
22924         return NULL;
22925     _rv = QTVideoOutputGetDisplayMode(vo,
22926                                       &displayModeID);
22927     _res = Py_BuildValue("ll",
22928                          _rv,
22929                          displayModeID);
22930     return _res;
22931 }
22932
22933 static PyObject *Qt_QTVideoOutputGetGWorld(PyObject *_self, PyObject *_args)
22934 {
22935     PyObject *_res = NULL;
22936     ComponentResult _rv;
22937     QTVideoOutputComponent vo;
22938     GWorldPtr gw;
22939 #ifndef QTVideoOutputGetGWorld
22940     PyMac_PRECHECK(QTVideoOutputGetGWorld);
22941 #endif
22942     if (!PyArg_ParseTuple(_args, "O&",
22943                           CmpInstObj_Convert, &vo))
22944         return NULL;
22945     _rv = QTVideoOutputGetGWorld(vo,
22946                                  &gw);
22947     _res = Py_BuildValue("lO&",
22948                          _rv,
22949                          GWorldObj_New, gw);
22950     return _res;
22951 }
22952
22953 static PyObject *Qt_QTVideoOutputGetIndSoundOutput(PyObject *_self, PyObject *_args)
22954 {
22955     PyObject *_res = NULL;
22956     ComponentResult _rv;
22957     QTVideoOutputComponent vo;
22958     long index;
22959     Component outputComponent;
22960 #ifndef QTVideoOutputGetIndSoundOutput
22961     PyMac_PRECHECK(QTVideoOutputGetIndSoundOutput);
22962 #endif
22963     if (!PyArg_ParseTuple(_args, "O&l",
22964                           CmpInstObj_Convert, &vo,
22965                           &index))
22966         return NULL;
22967     _rv = QTVideoOutputGetIndSoundOutput(vo,
22968                                          index,
22969                                          &outputComponent);
22970     _res = Py_BuildValue("lO&",
22971                          _rv,
22972                          CmpObj_New, outputComponent);
22973     return _res;
22974 }
22975
22976 static PyObject *Qt_QTVideoOutputGetClock(PyObject *_self, PyObject *_args)
22977 {
22978     PyObject *_res = NULL;
22979     ComponentResult _rv;
22980     QTVideoOutputComponent vo;
22981     ComponentInstance clock;
22982 #ifndef QTVideoOutputGetClock
22983     PyMac_PRECHECK(QTVideoOutputGetClock);
22984 #endif
22985     if (!PyArg_ParseTuple(_args, "O&",
22986                           CmpInstObj_Convert, &vo))
22987         return NULL;
22988     _rv = QTVideoOutputGetClock(vo,
22989                                 &clock);
22990     _res = Py_BuildValue("lO&",
22991                          _rv,
22992                          CmpInstObj_New, clock);
22993     return _res;
22994 }
22995
22996 static PyObject *Qt_QTVideoOutputSetEchoPort(PyObject *_self, PyObject *_args)
22997 {
22998     PyObject *_res = NULL;
22999     ComponentResult _rv;
23000     QTVideoOutputComponent vo;
23001     CGrafPtr echoPort;
23002 #ifndef QTVideoOutputSetEchoPort
23003     PyMac_PRECHECK(QTVideoOutputSetEchoPort);
23004 #endif
23005     if (!PyArg_ParseTuple(_args, "O&O&",
23006                           CmpInstObj_Convert, &vo,
23007                           GrafObj_Convert, &echoPort))
23008         return NULL;
23009     _rv = QTVideoOutputSetEchoPort(vo,
23010                                    echoPort);
23011     _res = Py_BuildValue("l",
23012                          _rv);
23013     return _res;
23014 }
23015
23016 static PyObject *Qt_QTVideoOutputGetIndImageDecompressor(PyObject *_self, PyObject *_args)
23017 {
23018     PyObject *_res = NULL;
23019     ComponentResult _rv;
23020     QTVideoOutputComponent vo;
23021     long index;
23022     Component codec;
23023 #ifndef QTVideoOutputGetIndImageDecompressor
23024     PyMac_PRECHECK(QTVideoOutputGetIndImageDecompressor);
23025 #endif
23026     if (!PyArg_ParseTuple(_args, "O&l",
23027                           CmpInstObj_Convert, &vo,
23028                           &index))
23029         return NULL;
23030     _rv = QTVideoOutputGetIndImageDecompressor(vo,
23031                                                index,
23032                                                &codec);
23033     _res = Py_BuildValue("lO&",
23034                          _rv,
23035                          CmpObj_New, codec);
23036     return _res;
23037 }
23038
23039 static PyObject *Qt_QTVideoOutputBaseSetEchoPort(PyObject *_self, PyObject *_args)
23040 {
23041     PyObject *_res = NULL;
23042     ComponentResult _rv;
23043     QTVideoOutputComponent vo;
23044     CGrafPtr echoPort;
23045 #ifndef QTVideoOutputBaseSetEchoPort
23046     PyMac_PRECHECK(QTVideoOutputBaseSetEchoPort);
23047 #endif
23048     if (!PyArg_ParseTuple(_args, "O&O&",
23049                           CmpInstObj_Convert, &vo,
23050                           GrafObj_Convert, &echoPort))
23051         return NULL;
23052     _rv = QTVideoOutputBaseSetEchoPort(vo,
23053                                        echoPort);
23054     _res = Py_BuildValue("l",
23055                          _rv);
23056     return _res;
23057 }
23058
23059 static PyObject *Qt_MediaSetChunkManagementFlags(PyObject *_self, PyObject *_args)
23060 {
23061     PyObject *_res = NULL;
23062     ComponentResult _rv;
23063     MediaHandler mh;
23064     UInt32 flags;
23065     UInt32 flagsMask;
23066 #ifndef MediaSetChunkManagementFlags
23067     PyMac_PRECHECK(MediaSetChunkManagementFlags);
23068 #endif
23069     if (!PyArg_ParseTuple(_args, "O&ll",
23070                           CmpInstObj_Convert, &mh,
23071                           &flags,
23072                           &flagsMask))
23073         return NULL;
23074     _rv = MediaSetChunkManagementFlags(mh,
23075                                        flags,
23076                                        flagsMask);
23077     _res = Py_BuildValue("l",
23078                          _rv);
23079     return _res;
23080 }
23081
23082 static PyObject *Qt_MediaGetChunkManagementFlags(PyObject *_self, PyObject *_args)
23083 {
23084     PyObject *_res = NULL;
23085     ComponentResult _rv;
23086     MediaHandler mh;
23087     UInt32 flags;
23088 #ifndef MediaGetChunkManagementFlags
23089     PyMac_PRECHECK(MediaGetChunkManagementFlags);
23090 #endif
23091     if (!PyArg_ParseTuple(_args, "O&",
23092                           CmpInstObj_Convert, &mh))
23093         return NULL;
23094     _rv = MediaGetChunkManagementFlags(mh,
23095                                        &flags);
23096     _res = Py_BuildValue("ll",
23097                          _rv,
23098                          flags);
23099     return _res;
23100 }
23101
23102 static PyObject *Qt_MediaSetPurgeableChunkMemoryAllowance(PyObject *_self, PyObject *_args)
23103 {
23104     PyObject *_res = NULL;
23105     ComponentResult _rv;
23106     MediaHandler mh;
23107     Size allowance;
23108 #ifndef MediaSetPurgeableChunkMemoryAllowance
23109     PyMac_PRECHECK(MediaSetPurgeableChunkMemoryAllowance);
23110 #endif
23111     if (!PyArg_ParseTuple(_args, "O&l",
23112                           CmpInstObj_Convert, &mh,
23113                           &allowance))
23114         return NULL;
23115     _rv = MediaSetPurgeableChunkMemoryAllowance(mh,
23116                                                 allowance);
23117     _res = Py_BuildValue("l",
23118                          _rv);
23119     return _res;
23120 }
23121
23122 static PyObject *Qt_MediaGetPurgeableChunkMemoryAllowance(PyObject *_self, PyObject *_args)
23123 {
23124     PyObject *_res = NULL;
23125     ComponentResult _rv;
23126     MediaHandler mh;
23127     Size allowance;
23128 #ifndef MediaGetPurgeableChunkMemoryAllowance
23129     PyMac_PRECHECK(MediaGetPurgeableChunkMemoryAllowance);
23130 #endif
23131     if (!PyArg_ParseTuple(_args, "O&",
23132                           CmpInstObj_Convert, &mh))
23133         return NULL;
23134     _rv = MediaGetPurgeableChunkMemoryAllowance(mh,
23135                                                 &allowance);
23136     _res = Py_BuildValue("ll",
23137                          _rv,
23138                          allowance);
23139     return _res;
23140 }
23141
23142 static PyObject *Qt_MediaEmptyAllPurgeableChunks(PyObject *_self, PyObject *_args)
23143 {
23144     PyObject *_res = NULL;
23145     ComponentResult _rv;
23146     MediaHandler mh;
23147 #ifndef MediaEmptyAllPurgeableChunks
23148     PyMac_PRECHECK(MediaEmptyAllPurgeableChunks);
23149 #endif
23150     if (!PyArg_ParseTuple(_args, "O&",
23151                           CmpInstObj_Convert, &mh))
23152         return NULL;
23153     _rv = MediaEmptyAllPurgeableChunks(mh);
23154     _res = Py_BuildValue("l",
23155                          _rv);
23156     return _res;
23157 }
23158
23159 static PyObject *Qt_MediaSetHandlerCapabilities(PyObject *_self, PyObject *_args)
23160 {
23161     PyObject *_res = NULL;
23162     ComponentResult _rv;
23163     MediaHandler mh;
23164     long flags;
23165     long flagsMask;
23166 #ifndef MediaSetHandlerCapabilities
23167     PyMac_PRECHECK(MediaSetHandlerCapabilities);
23168 #endif
23169     if (!PyArg_ParseTuple(_args, "O&ll",
23170                           CmpInstObj_Convert, &mh,
23171                           &flags,
23172                           &flagsMask))
23173         return NULL;
23174     _rv = MediaSetHandlerCapabilities(mh,
23175                                       flags,
23176                                       flagsMask);
23177     _res = Py_BuildValue("l",
23178                          _rv);
23179     return _res;
23180 }
23181
23182 static PyObject *Qt_MediaIdle(PyObject *_self, PyObject *_args)
23183 {
23184     PyObject *_res = NULL;
23185     ComponentResult _rv;
23186     MediaHandler mh;
23187     TimeValue atMediaTime;
23188     long flagsIn;
23189     long flagsOut;
23190     TimeRecord movieTime;
23191 #ifndef MediaIdle
23192     PyMac_PRECHECK(MediaIdle);
23193 #endif
23194     if (!PyArg_ParseTuple(_args, "O&llO&",
23195                           CmpInstObj_Convert, &mh,
23196                           &atMediaTime,
23197                           &flagsIn,
23198                           QtTimeRecord_Convert, &movieTime))
23199         return NULL;
23200     _rv = MediaIdle(mh,
23201                     atMediaTime,
23202                     flagsIn,
23203                     &flagsOut,
23204                     &movieTime);
23205     _res = Py_BuildValue("ll",
23206                          _rv,
23207                          flagsOut);
23208     return _res;
23209 }
23210
23211 static PyObject *Qt_MediaGetMediaInfo(PyObject *_self, PyObject *_args)
23212 {
23213     PyObject *_res = NULL;
23214     ComponentResult _rv;
23215     MediaHandler mh;
23216     Handle h;
23217 #ifndef MediaGetMediaInfo
23218     PyMac_PRECHECK(MediaGetMediaInfo);
23219 #endif
23220     if (!PyArg_ParseTuple(_args, "O&O&",
23221                           CmpInstObj_Convert, &mh,
23222                           ResObj_Convert, &h))
23223         return NULL;
23224     _rv = MediaGetMediaInfo(mh,
23225                             h);
23226     _res = Py_BuildValue("l",
23227                          _rv);
23228     return _res;
23229 }
23230
23231 static PyObject *Qt_MediaPutMediaInfo(PyObject *_self, PyObject *_args)
23232 {
23233     PyObject *_res = NULL;
23234     ComponentResult _rv;
23235     MediaHandler mh;
23236     Handle h;
23237 #ifndef MediaPutMediaInfo
23238     PyMac_PRECHECK(MediaPutMediaInfo);
23239 #endif
23240     if (!PyArg_ParseTuple(_args, "O&O&",
23241                           CmpInstObj_Convert, &mh,
23242                           ResObj_Convert, &h))
23243         return NULL;
23244     _rv = MediaPutMediaInfo(mh,
23245                             h);
23246     _res = Py_BuildValue("l",
23247                          _rv);
23248     return _res;
23249 }
23250
23251 static PyObject *Qt_MediaSetActive(PyObject *_self, PyObject *_args)
23252 {
23253     PyObject *_res = NULL;
23254     ComponentResult _rv;
23255     MediaHandler mh;
23256     Boolean enableMedia;
23257 #ifndef MediaSetActive
23258     PyMac_PRECHECK(MediaSetActive);
23259 #endif
23260     if (!PyArg_ParseTuple(_args, "O&b",
23261                           CmpInstObj_Convert, &mh,
23262                           &enableMedia))
23263         return NULL;
23264     _rv = MediaSetActive(mh,
23265                          enableMedia);
23266     _res = Py_BuildValue("l",
23267                          _rv);
23268     return _res;
23269 }
23270
23271 static PyObject *Qt_MediaSetRate(PyObject *_self, PyObject *_args)
23272 {
23273     PyObject *_res = NULL;
23274     ComponentResult _rv;
23275     MediaHandler mh;
23276     Fixed rate;
23277 #ifndef MediaSetRate
23278     PyMac_PRECHECK(MediaSetRate);
23279 #endif
23280     if (!PyArg_ParseTuple(_args, "O&O&",
23281                           CmpInstObj_Convert, &mh,
23282                           PyMac_GetFixed, &rate))
23283         return NULL;
23284     _rv = MediaSetRate(mh,
23285                        rate);
23286     _res = Py_BuildValue("l",
23287                          _rv);
23288     return _res;
23289 }
23290
23291 static PyObject *Qt_MediaGGetStatus(PyObject *_self, PyObject *_args)
23292 {
23293     PyObject *_res = NULL;
23294     ComponentResult _rv;
23295     MediaHandler mh;
23296     ComponentResult statusErr;
23297 #ifndef MediaGGetStatus
23298     PyMac_PRECHECK(MediaGGetStatus);
23299 #endif
23300     if (!PyArg_ParseTuple(_args, "O&",
23301                           CmpInstObj_Convert, &mh))
23302         return NULL;
23303     _rv = MediaGGetStatus(mh,
23304                           &statusErr);
23305     _res = Py_BuildValue("ll",
23306                          _rv,
23307                          statusErr);
23308     return _res;
23309 }
23310
23311 static PyObject *Qt_MediaTrackEdited(PyObject *_self, PyObject *_args)
23312 {
23313     PyObject *_res = NULL;
23314     ComponentResult _rv;
23315     MediaHandler mh;
23316 #ifndef MediaTrackEdited
23317     PyMac_PRECHECK(MediaTrackEdited);
23318 #endif
23319     if (!PyArg_ParseTuple(_args, "O&",
23320                           CmpInstObj_Convert, &mh))
23321         return NULL;
23322     _rv = MediaTrackEdited(mh);
23323     _res = Py_BuildValue("l",
23324                          _rv);
23325     return _res;
23326 }
23327
23328 static PyObject *Qt_MediaSetMediaTimeScale(PyObject *_self, PyObject *_args)
23329 {
23330     PyObject *_res = NULL;
23331     ComponentResult _rv;
23332     MediaHandler mh;
23333     TimeScale newTimeScale;
23334 #ifndef MediaSetMediaTimeScale
23335     PyMac_PRECHECK(MediaSetMediaTimeScale);
23336 #endif
23337     if (!PyArg_ParseTuple(_args, "O&l",
23338                           CmpInstObj_Convert, &mh,
23339                           &newTimeScale))
23340         return NULL;
23341     _rv = MediaSetMediaTimeScale(mh,
23342                                  newTimeScale);
23343     _res = Py_BuildValue("l",
23344                          _rv);
23345     return _res;
23346 }
23347
23348 static PyObject *Qt_MediaSetMovieTimeScale(PyObject *_self, PyObject *_args)
23349 {
23350     PyObject *_res = NULL;
23351     ComponentResult _rv;
23352     MediaHandler mh;
23353     TimeScale newTimeScale;
23354 #ifndef MediaSetMovieTimeScale
23355     PyMac_PRECHECK(MediaSetMovieTimeScale);
23356 #endif
23357     if (!PyArg_ParseTuple(_args, "O&l",
23358                           CmpInstObj_Convert, &mh,
23359                           &newTimeScale))
23360         return NULL;
23361     _rv = MediaSetMovieTimeScale(mh,
23362                                  newTimeScale);
23363     _res = Py_BuildValue("l",
23364                          _rv);
23365     return _res;
23366 }
23367
23368 static PyObject *Qt_MediaSetGWorld(PyObject *_self, PyObject *_args)
23369 {
23370     PyObject *_res = NULL;
23371     ComponentResult _rv;
23372     MediaHandler mh;
23373     CGrafPtr aPort;
23374     GDHandle aGD;
23375 #ifndef MediaSetGWorld
23376     PyMac_PRECHECK(MediaSetGWorld);
23377 #endif
23378     if (!PyArg_ParseTuple(_args, "O&O&O&",
23379                           CmpInstObj_Convert, &mh,
23380                           GrafObj_Convert, &aPort,
23381                           OptResObj_Convert, &aGD))
23382         return NULL;
23383     _rv = MediaSetGWorld(mh,
23384                          aPort,
23385                          aGD);
23386     _res = Py_BuildValue("l",
23387                          _rv);
23388     return _res;
23389 }
23390
23391 static PyObject *Qt_MediaSetDimensions(PyObject *_self, PyObject *_args)
23392 {
23393     PyObject *_res = NULL;
23394     ComponentResult _rv;
23395     MediaHandler mh;
23396     Fixed width;
23397     Fixed height;
23398 #ifndef MediaSetDimensions
23399     PyMac_PRECHECK(MediaSetDimensions);
23400 #endif
23401     if (!PyArg_ParseTuple(_args, "O&O&O&",
23402                           CmpInstObj_Convert, &mh,
23403                           PyMac_GetFixed, &width,
23404                           PyMac_GetFixed, &height))
23405         return NULL;
23406     _rv = MediaSetDimensions(mh,
23407                              width,
23408                              height);
23409     _res = Py_BuildValue("l",
23410                          _rv);
23411     return _res;
23412 }
23413
23414 static PyObject *Qt_MediaSetClip(PyObject *_self, PyObject *_args)
23415 {
23416     PyObject *_res = NULL;
23417     ComponentResult _rv;
23418     MediaHandler mh;
23419     RgnHandle theClip;
23420 #ifndef MediaSetClip
23421     PyMac_PRECHECK(MediaSetClip);
23422 #endif
23423     if (!PyArg_ParseTuple(_args, "O&O&",
23424                           CmpInstObj_Convert, &mh,
23425                           ResObj_Convert, &theClip))
23426         return NULL;
23427     _rv = MediaSetClip(mh,
23428                        theClip);
23429     _res = Py_BuildValue("l",
23430                          _rv);
23431     return _res;
23432 }
23433
23434 static PyObject *Qt_MediaGetTrackOpaque(PyObject *_self, PyObject *_args)
23435 {
23436     PyObject *_res = NULL;
23437     ComponentResult _rv;
23438     MediaHandler mh;
23439     Boolean trackIsOpaque;
23440 #ifndef MediaGetTrackOpaque
23441     PyMac_PRECHECK(MediaGetTrackOpaque);
23442 #endif
23443     if (!PyArg_ParseTuple(_args, "O&",
23444                           CmpInstObj_Convert, &mh))
23445         return NULL;
23446     _rv = MediaGetTrackOpaque(mh,
23447                               &trackIsOpaque);
23448     _res = Py_BuildValue("lb",
23449                          _rv,
23450                          trackIsOpaque);
23451     return _res;
23452 }
23453
23454 static PyObject *Qt_MediaSetGraphicsMode(PyObject *_self, PyObject *_args)
23455 {
23456     PyObject *_res = NULL;
23457     ComponentResult _rv;
23458     MediaHandler mh;
23459     long mode;
23460     RGBColor opColor;
23461 #ifndef MediaSetGraphicsMode
23462     PyMac_PRECHECK(MediaSetGraphicsMode);
23463 #endif
23464     if (!PyArg_ParseTuple(_args, "O&lO&",
23465                           CmpInstObj_Convert, &mh,
23466                           &mode,
23467                           QdRGB_Convert, &opColor))
23468         return NULL;
23469     _rv = MediaSetGraphicsMode(mh,
23470                                mode,
23471                                &opColor);
23472     _res = Py_BuildValue("l",
23473                          _rv);
23474     return _res;
23475 }
23476
23477 static PyObject *Qt_MediaGetGraphicsMode(PyObject *_self, PyObject *_args)
23478 {
23479     PyObject *_res = NULL;
23480     ComponentResult _rv;
23481     MediaHandler mh;
23482     long mode;
23483     RGBColor opColor;
23484 #ifndef MediaGetGraphicsMode
23485     PyMac_PRECHECK(MediaGetGraphicsMode);
23486 #endif
23487     if (!PyArg_ParseTuple(_args, "O&",
23488                           CmpInstObj_Convert, &mh))
23489         return NULL;
23490     _rv = MediaGetGraphicsMode(mh,
23491                                &mode,
23492                                &opColor);
23493     _res = Py_BuildValue("llO&",
23494                          _rv,
23495                          mode,
23496                          QdRGB_New, &opColor);
23497     return _res;
23498 }
23499
23500 static PyObject *Qt_MediaGSetVolume(PyObject *_self, PyObject *_args)
23501 {
23502     PyObject *_res = NULL;
23503     ComponentResult _rv;
23504     MediaHandler mh;
23505     short volume;
23506 #ifndef MediaGSetVolume
23507     PyMac_PRECHECK(MediaGSetVolume);
23508 #endif
23509     if (!PyArg_ParseTuple(_args, "O&h",
23510                           CmpInstObj_Convert, &mh,
23511                           &volume))
23512         return NULL;
23513     _rv = MediaGSetVolume(mh,
23514                           volume);
23515     _res = Py_BuildValue("l",
23516                          _rv);
23517     return _res;
23518 }
23519
23520 static PyObject *Qt_MediaSetSoundBalance(PyObject *_self, PyObject *_args)
23521 {
23522     PyObject *_res = NULL;
23523     ComponentResult _rv;
23524     MediaHandler mh;
23525     short balance;
23526 #ifndef MediaSetSoundBalance
23527     PyMac_PRECHECK(MediaSetSoundBalance);
23528 #endif
23529     if (!PyArg_ParseTuple(_args, "O&h",
23530                           CmpInstObj_Convert, &mh,
23531                           &balance))
23532         return NULL;
23533     _rv = MediaSetSoundBalance(mh,
23534                                balance);
23535     _res = Py_BuildValue("l",
23536                          _rv);
23537     return _res;
23538 }
23539
23540 static PyObject *Qt_MediaGetSoundBalance(PyObject *_self, PyObject *_args)
23541 {
23542     PyObject *_res = NULL;
23543     ComponentResult _rv;
23544     MediaHandler mh;
23545     short balance;
23546 #ifndef MediaGetSoundBalance
23547     PyMac_PRECHECK(MediaGetSoundBalance);
23548 #endif
23549     if (!PyArg_ParseTuple(_args, "O&",
23550                           CmpInstObj_Convert, &mh))
23551         return NULL;
23552     _rv = MediaGetSoundBalance(mh,
23553                                &balance);
23554     _res = Py_BuildValue("lh",
23555                          _rv,
23556                          balance);
23557     return _res;
23558 }
23559
23560 static PyObject *Qt_MediaGetNextBoundsChange(PyObject *_self, PyObject *_args)
23561 {
23562     PyObject *_res = NULL;
23563     ComponentResult _rv;
23564     MediaHandler mh;
23565     TimeValue when;
23566 #ifndef MediaGetNextBoundsChange
23567     PyMac_PRECHECK(MediaGetNextBoundsChange);
23568 #endif
23569     if (!PyArg_ParseTuple(_args, "O&",
23570                           CmpInstObj_Convert, &mh))
23571         return NULL;
23572     _rv = MediaGetNextBoundsChange(mh,
23573                                    &when);
23574     _res = Py_BuildValue("ll",
23575                          _rv,
23576                          when);
23577     return _res;
23578 }
23579
23580 static PyObject *Qt_MediaGetSrcRgn(PyObject *_self, PyObject *_args)
23581 {
23582     PyObject *_res = NULL;
23583     ComponentResult _rv;
23584     MediaHandler mh;
23585     RgnHandle rgn;
23586     TimeValue atMediaTime;
23587 #ifndef MediaGetSrcRgn
23588     PyMac_PRECHECK(MediaGetSrcRgn);
23589 #endif
23590     if (!PyArg_ParseTuple(_args, "O&O&l",
23591                           CmpInstObj_Convert, &mh,
23592                           ResObj_Convert, &rgn,
23593                           &atMediaTime))
23594         return NULL;
23595     _rv = MediaGetSrcRgn(mh,
23596                          rgn,
23597                          atMediaTime);
23598     _res = Py_BuildValue("l",
23599                          _rv);
23600     return _res;
23601 }
23602
23603 static PyObject *Qt_MediaPreroll(PyObject *_self, PyObject *_args)
23604 {
23605     PyObject *_res = NULL;
23606     ComponentResult _rv;
23607     MediaHandler mh;
23608     TimeValue time;
23609     Fixed rate;
23610 #ifndef MediaPreroll
23611     PyMac_PRECHECK(MediaPreroll);
23612 #endif
23613     if (!PyArg_ParseTuple(_args, "O&lO&",
23614                           CmpInstObj_Convert, &mh,
23615                           &time,
23616                           PyMac_GetFixed, &rate))
23617         return NULL;
23618     _rv = MediaPreroll(mh,
23619                        time,
23620                        rate);
23621     _res = Py_BuildValue("l",
23622                          _rv);
23623     return _res;
23624 }
23625
23626 static PyObject *Qt_MediaSampleDescriptionChanged(PyObject *_self, PyObject *_args)
23627 {
23628     PyObject *_res = NULL;
23629     ComponentResult _rv;
23630     MediaHandler mh;
23631     long index;
23632 #ifndef MediaSampleDescriptionChanged
23633     PyMac_PRECHECK(MediaSampleDescriptionChanged);
23634 #endif
23635     if (!PyArg_ParseTuple(_args, "O&l",
23636                           CmpInstObj_Convert, &mh,
23637                           &index))
23638         return NULL;
23639     _rv = MediaSampleDescriptionChanged(mh,
23640                                         index);
23641     _res = Py_BuildValue("l",
23642                          _rv);
23643     return _res;
23644 }
23645
23646 static PyObject *Qt_MediaHasCharacteristic(PyObject *_self, PyObject *_args)
23647 {
23648     PyObject *_res = NULL;
23649     ComponentResult _rv;
23650     MediaHandler mh;
23651     OSType characteristic;
23652     Boolean hasIt;
23653 #ifndef MediaHasCharacteristic
23654     PyMac_PRECHECK(MediaHasCharacteristic);
23655 #endif
23656     if (!PyArg_ParseTuple(_args, "O&O&",
23657                           CmpInstObj_Convert, &mh,
23658                           PyMac_GetOSType, &characteristic))
23659         return NULL;
23660     _rv = MediaHasCharacteristic(mh,
23661                                  characteristic,
23662                                  &hasIt);
23663     _res = Py_BuildValue("lb",
23664                          _rv,
23665                          hasIt);
23666     return _res;
23667 }
23668
23669 static PyObject *Qt_MediaGetOffscreenBufferSize(PyObject *_self, PyObject *_args)
23670 {
23671     PyObject *_res = NULL;
23672     ComponentResult _rv;
23673     MediaHandler mh;
23674     Rect bounds;
23675     short depth;
23676     CTabHandle ctab;
23677 #ifndef MediaGetOffscreenBufferSize
23678     PyMac_PRECHECK(MediaGetOffscreenBufferSize);
23679 #endif
23680     if (!PyArg_ParseTuple(_args, "O&hO&",
23681                           CmpInstObj_Convert, &mh,
23682                           &depth,
23683                           ResObj_Convert, &ctab))
23684         return NULL;
23685     _rv = MediaGetOffscreenBufferSize(mh,
23686                                       &bounds,
23687                                       depth,
23688                                       ctab);
23689     _res = Py_BuildValue("lO&",
23690                          _rv,
23691                          PyMac_BuildRect, &bounds);
23692     return _res;
23693 }
23694
23695 static PyObject *Qt_MediaSetHints(PyObject *_self, PyObject *_args)
23696 {
23697     PyObject *_res = NULL;
23698     ComponentResult _rv;
23699     MediaHandler mh;
23700     long hints;
23701 #ifndef MediaSetHints
23702     PyMac_PRECHECK(MediaSetHints);
23703 #endif
23704     if (!PyArg_ParseTuple(_args, "O&l",
23705                           CmpInstObj_Convert, &mh,
23706                           &hints))
23707         return NULL;
23708     _rv = MediaSetHints(mh,
23709                         hints);
23710     _res = Py_BuildValue("l",
23711                          _rv);
23712     return _res;
23713 }
23714
23715 static PyObject *Qt_MediaGetName(PyObject *_self, PyObject *_args)
23716 {
23717     PyObject *_res = NULL;
23718     ComponentResult _rv;
23719     MediaHandler mh;
23720     Str255 name;
23721     long requestedLanguage;
23722     long actualLanguage;
23723 #ifndef MediaGetName
23724     PyMac_PRECHECK(MediaGetName);
23725 #endif
23726     if (!PyArg_ParseTuple(_args, "O&O&l",
23727                           CmpInstObj_Convert, &mh,
23728                           PyMac_GetStr255, name,
23729                           &requestedLanguage))
23730         return NULL;
23731     _rv = MediaGetName(mh,
23732                        name,
23733                        requestedLanguage,
23734                        &actualLanguage);
23735     _res = Py_BuildValue("ll",
23736                          _rv,
23737                          actualLanguage);
23738     return _res;
23739 }
23740
23741 static PyObject *Qt_MediaForceUpdate(PyObject *_self, PyObject *_args)
23742 {
23743     PyObject *_res = NULL;
23744     ComponentResult _rv;
23745     MediaHandler mh;
23746     long forceUpdateFlags;
23747 #ifndef MediaForceUpdate
23748     PyMac_PRECHECK(MediaForceUpdate);
23749 #endif
23750     if (!PyArg_ParseTuple(_args, "O&l",
23751                           CmpInstObj_Convert, &mh,
23752                           &forceUpdateFlags))
23753         return NULL;
23754     _rv = MediaForceUpdate(mh,
23755                            forceUpdateFlags);
23756     _res = Py_BuildValue("l",
23757                          _rv);
23758     return _res;
23759 }
23760
23761 static PyObject *Qt_MediaGetDrawingRgn(PyObject *_self, PyObject *_args)
23762 {
23763     PyObject *_res = NULL;
23764     ComponentResult _rv;
23765     MediaHandler mh;
23766     RgnHandle partialRgn;
23767 #ifndef MediaGetDrawingRgn
23768     PyMac_PRECHECK(MediaGetDrawingRgn);
23769 #endif
23770     if (!PyArg_ParseTuple(_args, "O&",
23771                           CmpInstObj_Convert, &mh))
23772         return NULL;
23773     _rv = MediaGetDrawingRgn(mh,
23774                              &partialRgn);
23775     _res = Py_BuildValue("lO&",
23776                          _rv,
23777                          ResObj_New, partialRgn);
23778     return _res;
23779 }
23780
23781 static PyObject *Qt_MediaGSetActiveSegment(PyObject *_self, PyObject *_args)
23782 {
23783     PyObject *_res = NULL;
23784     ComponentResult _rv;
23785     MediaHandler mh;
23786     TimeValue activeStart;
23787     TimeValue activeDuration;
23788 #ifndef MediaGSetActiveSegment
23789     PyMac_PRECHECK(MediaGSetActiveSegment);
23790 #endif
23791     if (!PyArg_ParseTuple(_args, "O&ll",
23792                           CmpInstObj_Convert, &mh,
23793                           &activeStart,
23794                           &activeDuration))
23795         return NULL;
23796     _rv = MediaGSetActiveSegment(mh,
23797                                  activeStart,
23798                                  activeDuration);
23799     _res = Py_BuildValue("l",
23800                          _rv);
23801     return _res;
23802 }
23803
23804 static PyObject *Qt_MediaInvalidateRegion(PyObject *_self, PyObject *_args)
23805 {
23806     PyObject *_res = NULL;
23807     ComponentResult _rv;
23808     MediaHandler mh;
23809     RgnHandle invalRgn;
23810 #ifndef MediaInvalidateRegion
23811     PyMac_PRECHECK(MediaInvalidateRegion);
23812 #endif
23813     if (!PyArg_ParseTuple(_args, "O&O&",
23814                           CmpInstObj_Convert, &mh,
23815                           ResObj_Convert, &invalRgn))
23816         return NULL;
23817     _rv = MediaInvalidateRegion(mh,
23818                                 invalRgn);
23819     _res = Py_BuildValue("l",
23820                          _rv);
23821     return _res;
23822 }
23823
23824 static PyObject *Qt_MediaGetNextStepTime(PyObject *_self, PyObject *_args)
23825 {
23826     PyObject *_res = NULL;
23827     ComponentResult _rv;
23828     MediaHandler mh;
23829     short flags;
23830     TimeValue mediaTimeIn;
23831     TimeValue mediaTimeOut;
23832     Fixed rate;
23833 #ifndef MediaGetNextStepTime
23834     PyMac_PRECHECK(MediaGetNextStepTime);
23835 #endif
23836     if (!PyArg_ParseTuple(_args, "O&hlO&",
23837                           CmpInstObj_Convert, &mh,
23838                           &flags,
23839                           &mediaTimeIn,
23840                           PyMac_GetFixed, &rate))
23841         return NULL;
23842     _rv = MediaGetNextStepTime(mh,
23843                                flags,
23844                                mediaTimeIn,
23845                                &mediaTimeOut,
23846                                rate);
23847     _res = Py_BuildValue("ll",
23848                          _rv,
23849                          mediaTimeOut);
23850     return _res;
23851 }
23852
23853 static PyObject *Qt_MediaChangedNonPrimarySource(PyObject *_self, PyObject *_args)
23854 {
23855     PyObject *_res = NULL;
23856     ComponentResult _rv;
23857     MediaHandler mh;
23858     long inputIndex;
23859 #ifndef MediaChangedNonPrimarySource
23860     PyMac_PRECHECK(MediaChangedNonPrimarySource);
23861 #endif
23862     if (!PyArg_ParseTuple(_args, "O&l",
23863                           CmpInstObj_Convert, &mh,
23864                           &inputIndex))
23865         return NULL;
23866     _rv = MediaChangedNonPrimarySource(mh,
23867                                        inputIndex);
23868     _res = Py_BuildValue("l",
23869                          _rv);
23870     return _res;
23871 }
23872
23873 static PyObject *Qt_MediaTrackReferencesChanged(PyObject *_self, PyObject *_args)
23874 {
23875     PyObject *_res = NULL;
23876     ComponentResult _rv;
23877     MediaHandler mh;
23878 #ifndef MediaTrackReferencesChanged
23879     PyMac_PRECHECK(MediaTrackReferencesChanged);
23880 #endif
23881     if (!PyArg_ParseTuple(_args, "O&",
23882                           CmpInstObj_Convert, &mh))
23883         return NULL;
23884     _rv = MediaTrackReferencesChanged(mh);
23885     _res = Py_BuildValue("l",
23886                          _rv);
23887     return _res;
23888 }
23889
23890 static PyObject *Qt_MediaReleaseSampleDataPointer(PyObject *_self, PyObject *_args)
23891 {
23892     PyObject *_res = NULL;
23893     ComponentResult _rv;
23894     MediaHandler mh;
23895     long sampleNum;
23896 #ifndef MediaReleaseSampleDataPointer
23897     PyMac_PRECHECK(MediaReleaseSampleDataPointer);
23898 #endif
23899     if (!PyArg_ParseTuple(_args, "O&l",
23900                           CmpInstObj_Convert, &mh,
23901                           &sampleNum))
23902         return NULL;
23903     _rv = MediaReleaseSampleDataPointer(mh,
23904                                         sampleNum);
23905     _res = Py_BuildValue("l",
23906                          _rv);
23907     return _res;
23908 }
23909
23910 static PyObject *Qt_MediaTrackPropertyAtomChanged(PyObject *_self, PyObject *_args)
23911 {
23912     PyObject *_res = NULL;
23913     ComponentResult _rv;
23914     MediaHandler mh;
23915 #ifndef MediaTrackPropertyAtomChanged
23916     PyMac_PRECHECK(MediaTrackPropertyAtomChanged);
23917 #endif
23918     if (!PyArg_ParseTuple(_args, "O&",
23919                           CmpInstObj_Convert, &mh))
23920         return NULL;
23921     _rv = MediaTrackPropertyAtomChanged(mh);
23922     _res = Py_BuildValue("l",
23923                          _rv);
23924     return _res;
23925 }
23926
23927 static PyObject *Qt_MediaSetVideoParam(PyObject *_self, PyObject *_args)
23928 {
23929     PyObject *_res = NULL;
23930     ComponentResult _rv;
23931     MediaHandler mh;
23932     long whichParam;
23933     unsigned short value;
23934 #ifndef MediaSetVideoParam
23935     PyMac_PRECHECK(MediaSetVideoParam);
23936 #endif
23937     if (!PyArg_ParseTuple(_args, "O&l",
23938                           CmpInstObj_Convert, &mh,
23939                           &whichParam))
23940         return NULL;
23941     _rv = MediaSetVideoParam(mh,
23942                              whichParam,
23943                              &value);
23944     _res = Py_BuildValue("lH",
23945                          _rv,
23946                          value);
23947     return _res;
23948 }
23949
23950 static PyObject *Qt_MediaGetVideoParam(PyObject *_self, PyObject *_args)
23951 {
23952     PyObject *_res = NULL;
23953     ComponentResult _rv;
23954     MediaHandler mh;
23955     long whichParam;
23956     unsigned short value;
23957 #ifndef MediaGetVideoParam
23958     PyMac_PRECHECK(MediaGetVideoParam);
23959 #endif
23960     if (!PyArg_ParseTuple(_args, "O&l",
23961                           CmpInstObj_Convert, &mh,
23962                           &whichParam))
23963         return NULL;
23964     _rv = MediaGetVideoParam(mh,
23965                              whichParam,
23966                              &value);
23967     _res = Py_BuildValue("lH",
23968                          _rv,
23969                          value);
23970     return _res;
23971 }
23972
23973 static PyObject *Qt_MediaCompare(PyObject *_self, PyObject *_args)
23974 {
23975     PyObject *_res = NULL;
23976     ComponentResult _rv;
23977     MediaHandler mh;
23978     Boolean isOK;
23979     Media srcMedia;
23980     ComponentInstance srcMediaComponent;
23981 #ifndef MediaCompare
23982     PyMac_PRECHECK(MediaCompare);
23983 #endif
23984     if (!PyArg_ParseTuple(_args, "O&O&O&",
23985                           CmpInstObj_Convert, &mh,
23986                           MediaObj_Convert, &srcMedia,
23987                           CmpInstObj_Convert, &srcMediaComponent))
23988         return NULL;
23989     _rv = MediaCompare(mh,
23990                        &isOK,
23991                        srcMedia,
23992                        srcMediaComponent);
23993     _res = Py_BuildValue("lb",
23994                          _rv,
23995                          isOK);
23996     return _res;
23997 }
23998
23999 static PyObject *Qt_MediaGetClock(PyObject *_self, PyObject *_args)
24000 {
24001     PyObject *_res = NULL;
24002     ComponentResult _rv;
24003     MediaHandler mh;
24004     ComponentInstance clock;
24005 #ifndef MediaGetClock
24006     PyMac_PRECHECK(MediaGetClock);
24007 #endif
24008     if (!PyArg_ParseTuple(_args, "O&",
24009                           CmpInstObj_Convert, &mh))
24010         return NULL;
24011     _rv = MediaGetClock(mh,
24012                         &clock);
24013     _res = Py_BuildValue("lO&",
24014                          _rv,
24015                          CmpInstObj_New, clock);
24016     return _res;
24017 }
24018
24019 static PyObject *Qt_MediaSetSoundOutputComponent(PyObject *_self, PyObject *_args)
24020 {
24021     PyObject *_res = NULL;
24022     ComponentResult _rv;
24023     MediaHandler mh;
24024     Component outputComponent;
24025 #ifndef MediaSetSoundOutputComponent
24026     PyMac_PRECHECK(MediaSetSoundOutputComponent);
24027 #endif
24028     if (!PyArg_ParseTuple(_args, "O&O&",
24029                           CmpInstObj_Convert, &mh,
24030                           CmpObj_Convert, &outputComponent))
24031         return NULL;
24032     _rv = MediaSetSoundOutputComponent(mh,
24033                                        outputComponent);
24034     _res = Py_BuildValue("l",
24035                          _rv);
24036     return _res;
24037 }
24038
24039 static PyObject *Qt_MediaGetSoundOutputComponent(PyObject *_self, PyObject *_args)
24040 {
24041     PyObject *_res = NULL;
24042     ComponentResult _rv;
24043     MediaHandler mh;
24044     Component outputComponent;
24045 #ifndef MediaGetSoundOutputComponent
24046     PyMac_PRECHECK(MediaGetSoundOutputComponent);
24047 #endif
24048     if (!PyArg_ParseTuple(_args, "O&",
24049                           CmpInstObj_Convert, &mh))
24050         return NULL;
24051     _rv = MediaGetSoundOutputComponent(mh,
24052                                        &outputComponent);
24053     _res = Py_BuildValue("lO&",
24054                          _rv,
24055                          CmpObj_New, outputComponent);
24056     return _res;
24057 }
24058
24059 static PyObject *Qt_MediaSetSoundLocalizationData(PyObject *_self, PyObject *_args)
24060 {
24061     PyObject *_res = NULL;
24062     ComponentResult _rv;
24063     MediaHandler mh;
24064     Handle data;
24065 #ifndef MediaSetSoundLocalizationData
24066     PyMac_PRECHECK(MediaSetSoundLocalizationData);
24067 #endif
24068     if (!PyArg_ParseTuple(_args, "O&O&",
24069                           CmpInstObj_Convert, &mh,
24070                           ResObj_Convert, &data))
24071         return NULL;
24072     _rv = MediaSetSoundLocalizationData(mh,
24073                                         data);
24074     _res = Py_BuildValue("l",
24075                          _rv);
24076     return _res;
24077 }
24078
24079 static PyObject *Qt_MediaGetInvalidRegion(PyObject *_self, PyObject *_args)
24080 {
24081     PyObject *_res = NULL;
24082     ComponentResult _rv;
24083     MediaHandler mh;
24084     RgnHandle rgn;
24085 #ifndef MediaGetInvalidRegion
24086     PyMac_PRECHECK(MediaGetInvalidRegion);
24087 #endif
24088     if (!PyArg_ParseTuple(_args, "O&O&",
24089                           CmpInstObj_Convert, &mh,
24090                           ResObj_Convert, &rgn))
24091         return NULL;
24092     _rv = MediaGetInvalidRegion(mh,
24093                                 rgn);
24094     _res = Py_BuildValue("l",
24095                          _rv);
24096     return _res;
24097 }
24098
24099 static PyObject *Qt_MediaSampleDescriptionB2N(PyObject *_self, PyObject *_args)
24100 {
24101     PyObject *_res = NULL;
24102     ComponentResult _rv;
24103     MediaHandler mh;
24104     SampleDescriptionHandle sampleDescriptionH;
24105 #ifndef MediaSampleDescriptionB2N
24106     PyMac_PRECHECK(MediaSampleDescriptionB2N);
24107 #endif
24108     if (!PyArg_ParseTuple(_args, "O&O&",
24109                           CmpInstObj_Convert, &mh,
24110                           ResObj_Convert, &sampleDescriptionH))
24111         return NULL;
24112     _rv = MediaSampleDescriptionB2N(mh,
24113                                     sampleDescriptionH);
24114     _res = Py_BuildValue("l",
24115                          _rv);
24116     return _res;
24117 }
24118
24119 static PyObject *Qt_MediaSampleDescriptionN2B(PyObject *_self, PyObject *_args)
24120 {
24121     PyObject *_res = NULL;
24122     ComponentResult _rv;
24123     MediaHandler mh;
24124     SampleDescriptionHandle sampleDescriptionH;
24125 #ifndef MediaSampleDescriptionN2B
24126     PyMac_PRECHECK(MediaSampleDescriptionN2B);
24127 #endif
24128     if (!PyArg_ParseTuple(_args, "O&O&",
24129                           CmpInstObj_Convert, &mh,
24130                           ResObj_Convert, &sampleDescriptionH))
24131         return NULL;
24132     _rv = MediaSampleDescriptionN2B(mh,
24133                                     sampleDescriptionH);
24134     _res = Py_BuildValue("l",
24135                          _rv);
24136     return _res;
24137 }
24138
24139 static PyObject *Qt_MediaFlushNonPrimarySourceData(PyObject *_self, PyObject *_args)
24140 {
24141     PyObject *_res = NULL;
24142     ComponentResult _rv;
24143     MediaHandler mh;
24144     long inputIndex;
24145 #ifndef MediaFlushNonPrimarySourceData
24146     PyMac_PRECHECK(MediaFlushNonPrimarySourceData);
24147 #endif
24148     if (!PyArg_ParseTuple(_args, "O&l",
24149                           CmpInstObj_Convert, &mh,
24150                           &inputIndex))
24151         return NULL;
24152     _rv = MediaFlushNonPrimarySourceData(mh,
24153                                          inputIndex);
24154     _res = Py_BuildValue("l",
24155                          _rv);
24156     return _res;
24157 }
24158
24159 static PyObject *Qt_MediaGetURLLink(PyObject *_self, PyObject *_args)
24160 {
24161     PyObject *_res = NULL;
24162     ComponentResult _rv;
24163     MediaHandler mh;
24164     Point displayWhere;
24165     Handle urlLink;
24166 #ifndef MediaGetURLLink
24167     PyMac_PRECHECK(MediaGetURLLink);
24168 #endif
24169     if (!PyArg_ParseTuple(_args, "O&O&",
24170                           CmpInstObj_Convert, &mh,
24171                           PyMac_GetPoint, &displayWhere))
24172         return NULL;
24173     _rv = MediaGetURLLink(mh,
24174                           displayWhere,
24175                           &urlLink);
24176     _res = Py_BuildValue("lO&",
24177                          _rv,
24178                          ResObj_New, urlLink);
24179     return _res;
24180 }
24181
24182 static PyObject *Qt_MediaHitTestForTargetRefCon(PyObject *_self, PyObject *_args)
24183 {
24184     PyObject *_res = NULL;
24185     ComponentResult _rv;
24186     MediaHandler mh;
24187     long flags;
24188     Point loc;
24189     long targetRefCon;
24190 #ifndef MediaHitTestForTargetRefCon
24191     PyMac_PRECHECK(MediaHitTestForTargetRefCon);
24192 #endif
24193     if (!PyArg_ParseTuple(_args, "O&lO&",
24194                           CmpInstObj_Convert, &mh,
24195                           &flags,
24196                           PyMac_GetPoint, &loc))
24197         return NULL;
24198     _rv = MediaHitTestForTargetRefCon(mh,
24199                                       flags,
24200                                       loc,
24201                                       &targetRefCon);
24202     _res = Py_BuildValue("ll",
24203                          _rv,
24204                          targetRefCon);
24205     return _res;
24206 }
24207
24208 static PyObject *Qt_MediaHitTestTargetRefCon(PyObject *_self, PyObject *_args)
24209 {
24210     PyObject *_res = NULL;
24211     ComponentResult _rv;
24212     MediaHandler mh;
24213     long targetRefCon;
24214     long flags;
24215     Point loc;
24216     Boolean wasHit;
24217 #ifndef MediaHitTestTargetRefCon
24218     PyMac_PRECHECK(MediaHitTestTargetRefCon);
24219 #endif
24220     if (!PyArg_ParseTuple(_args, "O&llO&",
24221                           CmpInstObj_Convert, &mh,
24222                           &targetRefCon,
24223                           &flags,
24224                           PyMac_GetPoint, &loc))
24225         return NULL;
24226     _rv = MediaHitTestTargetRefCon(mh,
24227                                    targetRefCon,
24228                                    flags,
24229                                    loc,
24230                                    &wasHit);
24231     _res = Py_BuildValue("lb",
24232                          _rv,
24233                          wasHit);
24234     return _res;
24235 }
24236
24237 static PyObject *Qt_MediaDisposeTargetRefCon(PyObject *_self, PyObject *_args)
24238 {
24239     PyObject *_res = NULL;
24240     ComponentResult _rv;
24241     MediaHandler mh;
24242     long targetRefCon;
24243 #ifndef MediaDisposeTargetRefCon
24244     PyMac_PRECHECK(MediaDisposeTargetRefCon);
24245 #endif
24246     if (!PyArg_ParseTuple(_args, "O&l",
24247                           CmpInstObj_Convert, &mh,
24248                           &targetRefCon))
24249         return NULL;
24250     _rv = MediaDisposeTargetRefCon(mh,
24251                                    targetRefCon);
24252     _res = Py_BuildValue("l",
24253                          _rv);
24254     return _res;
24255 }
24256
24257 static PyObject *Qt_MediaTargetRefConsEqual(PyObject *_self, PyObject *_args)
24258 {
24259     PyObject *_res = NULL;
24260     ComponentResult _rv;
24261     MediaHandler mh;
24262     long firstRefCon;
24263     long secondRefCon;
24264     Boolean equal;
24265 #ifndef MediaTargetRefConsEqual
24266     PyMac_PRECHECK(MediaTargetRefConsEqual);
24267 #endif
24268     if (!PyArg_ParseTuple(_args, "O&ll",
24269                           CmpInstObj_Convert, &mh,
24270                           &firstRefCon,
24271                           &secondRefCon))
24272         return NULL;
24273     _rv = MediaTargetRefConsEqual(mh,
24274                                   firstRefCon,
24275                                   secondRefCon,
24276                                   &equal);
24277     _res = Py_BuildValue("lb",
24278                          _rv,
24279                          equal);
24280     return _res;
24281 }
24282
24283 static PyObject *Qt_MediaPrePrerollCancel(PyObject *_self, PyObject *_args)
24284 {
24285     PyObject *_res = NULL;
24286     ComponentResult _rv;
24287     MediaHandler mh;
24288     void * refcon;
24289 #ifndef MediaPrePrerollCancel
24290     PyMac_PRECHECK(MediaPrePrerollCancel);
24291 #endif
24292     if (!PyArg_ParseTuple(_args, "O&s",
24293                           CmpInstObj_Convert, &mh,
24294                           &refcon))
24295         return NULL;
24296     _rv = MediaPrePrerollCancel(mh,
24297                                 refcon);
24298     _res = Py_BuildValue("l",
24299                          _rv);
24300     return _res;
24301 }
24302
24303 static PyObject *Qt_MediaEnterEmptyEdit(PyObject *_self, PyObject *_args)
24304 {
24305     PyObject *_res = NULL;
24306     ComponentResult _rv;
24307     MediaHandler mh;
24308 #ifndef MediaEnterEmptyEdit
24309     PyMac_PRECHECK(MediaEnterEmptyEdit);
24310 #endif
24311     if (!PyArg_ParseTuple(_args, "O&",
24312                           CmpInstObj_Convert, &mh))
24313         return NULL;
24314     _rv = MediaEnterEmptyEdit(mh);
24315     _res = Py_BuildValue("l",
24316                          _rv);
24317     return _res;
24318 }
24319
24320 static PyObject *Qt_MediaCurrentMediaQueuedData(PyObject *_self, PyObject *_args)
24321 {
24322     PyObject *_res = NULL;
24323     ComponentResult _rv;
24324     MediaHandler mh;
24325     long milliSecs;
24326 #ifndef MediaCurrentMediaQueuedData
24327     PyMac_PRECHECK(MediaCurrentMediaQueuedData);
24328 #endif
24329     if (!PyArg_ParseTuple(_args, "O&",
24330                           CmpInstObj_Convert, &mh))
24331         return NULL;
24332     _rv = MediaCurrentMediaQueuedData(mh,
24333                                       &milliSecs);
24334     _res = Py_BuildValue("ll",
24335                          _rv,
24336                          milliSecs);
24337     return _res;
24338 }
24339
24340 static PyObject *Qt_MediaGetEffectiveVolume(PyObject *_self, PyObject *_args)
24341 {
24342     PyObject *_res = NULL;
24343     ComponentResult _rv;
24344     MediaHandler mh;
24345     short volume;
24346 #ifndef MediaGetEffectiveVolume
24347     PyMac_PRECHECK(MediaGetEffectiveVolume);
24348 #endif
24349     if (!PyArg_ParseTuple(_args, "O&",
24350                           CmpInstObj_Convert, &mh))
24351         return NULL;
24352     _rv = MediaGetEffectiveVolume(mh,
24353                                   &volume);
24354     _res = Py_BuildValue("lh",
24355                          _rv,
24356                          volume);
24357     return _res;
24358 }
24359
24360 static PyObject *Qt_MediaGetSoundLevelMeteringEnabled(PyObject *_self, PyObject *_args)
24361 {
24362     PyObject *_res = NULL;
24363     ComponentResult _rv;
24364     MediaHandler mh;
24365     Boolean enabled;
24366 #ifndef MediaGetSoundLevelMeteringEnabled
24367     PyMac_PRECHECK(MediaGetSoundLevelMeteringEnabled);
24368 #endif
24369     if (!PyArg_ParseTuple(_args, "O&",
24370                           CmpInstObj_Convert, &mh))
24371         return NULL;
24372     _rv = MediaGetSoundLevelMeteringEnabled(mh,
24373                                             &enabled);
24374     _res = Py_BuildValue("lb",
24375                          _rv,
24376                          enabled);
24377     return _res;
24378 }
24379
24380 static PyObject *Qt_MediaSetSoundLevelMeteringEnabled(PyObject *_self, PyObject *_args)
24381 {
24382     PyObject *_res = NULL;
24383     ComponentResult _rv;
24384     MediaHandler mh;
24385     Boolean enable;
24386 #ifndef MediaSetSoundLevelMeteringEnabled
24387     PyMac_PRECHECK(MediaSetSoundLevelMeteringEnabled);
24388 #endif
24389     if (!PyArg_ParseTuple(_args, "O&b",
24390                           CmpInstObj_Convert, &mh,
24391                           &enable))
24392         return NULL;
24393     _rv = MediaSetSoundLevelMeteringEnabled(mh,
24394                                             enable);
24395     _res = Py_BuildValue("l",
24396                          _rv);
24397     return _res;
24398 }
24399
24400 static PyObject *Qt_MediaGetEffectiveSoundBalance(PyObject *_self, PyObject *_args)
24401 {
24402     PyObject *_res = NULL;
24403     ComponentResult _rv;
24404     MediaHandler mh;
24405     short balance;
24406 #ifndef MediaGetEffectiveSoundBalance
24407     PyMac_PRECHECK(MediaGetEffectiveSoundBalance);
24408 #endif
24409     if (!PyArg_ParseTuple(_args, "O&",
24410                           CmpInstObj_Convert, &mh))
24411         return NULL;
24412     _rv = MediaGetEffectiveSoundBalance(mh,
24413                                         &balance);
24414     _res = Py_BuildValue("lh",
24415                          _rv,
24416                          balance);
24417     return _res;
24418 }
24419
24420 static PyObject *Qt_MediaSetScreenLock(PyObject *_self, PyObject *_args)
24421 {
24422     PyObject *_res = NULL;
24423     ComponentResult _rv;
24424     MediaHandler mh;
24425     Boolean lockIt;
24426 #ifndef MediaSetScreenLock
24427     PyMac_PRECHECK(MediaSetScreenLock);
24428 #endif
24429     if (!PyArg_ParseTuple(_args, "O&b",
24430                           CmpInstObj_Convert, &mh,
24431                           &lockIt))
24432         return NULL;
24433     _rv = MediaSetScreenLock(mh,
24434                              lockIt);
24435     _res = Py_BuildValue("l",
24436                          _rv);
24437     return _res;
24438 }
24439
24440 static PyObject *Qt_MediaGetErrorString(PyObject *_self, PyObject *_args)
24441 {
24442     PyObject *_res = NULL;
24443     ComponentResult _rv;
24444     MediaHandler mh;
24445     ComponentResult theError;
24446     Str255 errorString;
24447 #ifndef MediaGetErrorString
24448     PyMac_PRECHECK(MediaGetErrorString);
24449 #endif
24450     if (!PyArg_ParseTuple(_args, "O&lO&",
24451                           CmpInstObj_Convert, &mh,
24452                           &theError,
24453                           PyMac_GetStr255, errorString))
24454         return NULL;
24455     _rv = MediaGetErrorString(mh,
24456                               theError,
24457                               errorString);
24458     _res = Py_BuildValue("l",
24459                          _rv);
24460     return _res;
24461 }
24462
24463 static PyObject *Qt_MediaGetSoundEqualizerBandLevels(PyObject *_self, PyObject *_args)
24464 {
24465     PyObject *_res = NULL;
24466     ComponentResult _rv;
24467     MediaHandler mh;
24468     UInt8 bandLevels;
24469 #ifndef MediaGetSoundEqualizerBandLevels
24470     PyMac_PRECHECK(MediaGetSoundEqualizerBandLevels);
24471 #endif
24472     if (!PyArg_ParseTuple(_args, "O&",
24473                           CmpInstObj_Convert, &mh))
24474         return NULL;
24475     _rv = MediaGetSoundEqualizerBandLevels(mh,
24476                                            &bandLevels);
24477     _res = Py_BuildValue("lb",
24478                          _rv,
24479                          bandLevels);
24480     return _res;
24481 }
24482
24483 static PyObject *Qt_MediaDoIdleActions(PyObject *_self, PyObject *_args)
24484 {
24485     PyObject *_res = NULL;
24486     ComponentResult _rv;
24487     MediaHandler mh;
24488 #ifndef MediaDoIdleActions
24489     PyMac_PRECHECK(MediaDoIdleActions);
24490 #endif
24491     if (!PyArg_ParseTuple(_args, "O&",
24492                           CmpInstObj_Convert, &mh))
24493         return NULL;
24494     _rv = MediaDoIdleActions(mh);
24495     _res = Py_BuildValue("l",
24496                          _rv);
24497     return _res;
24498 }
24499
24500 static PyObject *Qt_MediaSetSoundBassAndTreble(PyObject *_self, PyObject *_args)
24501 {
24502     PyObject *_res = NULL;
24503     ComponentResult _rv;
24504     MediaHandler mh;
24505     short bass;
24506     short treble;
24507 #ifndef MediaSetSoundBassAndTreble
24508     PyMac_PRECHECK(MediaSetSoundBassAndTreble);
24509 #endif
24510     if (!PyArg_ParseTuple(_args, "O&hh",
24511                           CmpInstObj_Convert, &mh,
24512                           &bass,
24513                           &treble))
24514         return NULL;
24515     _rv = MediaSetSoundBassAndTreble(mh,
24516                                      bass,
24517                                      treble);
24518     _res = Py_BuildValue("l",
24519                          _rv);
24520     return _res;
24521 }
24522
24523 static PyObject *Qt_MediaGetSoundBassAndTreble(PyObject *_self, PyObject *_args)
24524 {
24525     PyObject *_res = NULL;
24526     ComponentResult _rv;
24527     MediaHandler mh;
24528     short bass;
24529     short treble;
24530 #ifndef MediaGetSoundBassAndTreble
24531     PyMac_PRECHECK(MediaGetSoundBassAndTreble);
24532 #endif
24533     if (!PyArg_ParseTuple(_args, "O&",
24534                           CmpInstObj_Convert, &mh))
24535         return NULL;
24536     _rv = MediaGetSoundBassAndTreble(mh,
24537                                      &bass,
24538                                      &treble);
24539     _res = Py_BuildValue("lhh",
24540                          _rv,
24541                          bass,
24542                          treble);
24543     return _res;
24544 }
24545
24546 static PyObject *Qt_MediaTimeBaseChanged(PyObject *_self, PyObject *_args)
24547 {
24548     PyObject *_res = NULL;
24549     ComponentResult _rv;
24550     MediaHandler mh;
24551 #ifndef MediaTimeBaseChanged
24552     PyMac_PRECHECK(MediaTimeBaseChanged);
24553 #endif
24554     if (!PyArg_ParseTuple(_args, "O&",
24555                           CmpInstObj_Convert, &mh))
24556         return NULL;
24557     _rv = MediaTimeBaseChanged(mh);
24558     _res = Py_BuildValue("l",
24559                          _rv);
24560     return _res;
24561 }
24562
24563 static PyObject *Qt_MediaMCIsPlayerEvent(PyObject *_self, PyObject *_args)
24564 {
24565     PyObject *_res = NULL;
24566     ComponentResult _rv;
24567     MediaHandler mh;
24568     EventRecord e;
24569     Boolean handledIt;
24570 #ifndef MediaMCIsPlayerEvent
24571     PyMac_PRECHECK(MediaMCIsPlayerEvent);
24572 #endif
24573     if (!PyArg_ParseTuple(_args, "O&O&",
24574                           CmpInstObj_Convert, &mh,
24575                           PyMac_GetEventRecord, &e))
24576         return NULL;
24577     _rv = MediaMCIsPlayerEvent(mh,
24578                                &e,
24579                                &handledIt);
24580     _res = Py_BuildValue("lb",
24581                          _rv,
24582                          handledIt);
24583     return _res;
24584 }
24585
24586 static PyObject *Qt_MediaGetMediaLoadState(PyObject *_self, PyObject *_args)
24587 {
24588     PyObject *_res = NULL;
24589     ComponentResult _rv;
24590     MediaHandler mh;
24591     long mediaLoadState;
24592 #ifndef MediaGetMediaLoadState
24593     PyMac_PRECHECK(MediaGetMediaLoadState);
24594 #endif
24595     if (!PyArg_ParseTuple(_args, "O&",
24596                           CmpInstObj_Convert, &mh))
24597         return NULL;
24598     _rv = MediaGetMediaLoadState(mh,
24599                                  &mediaLoadState);
24600     _res = Py_BuildValue("ll",
24601                          _rv,
24602                          mediaLoadState);
24603     return _res;
24604 }
24605
24606 static PyObject *Qt_MediaVideoOutputChanged(PyObject *_self, PyObject *_args)
24607 {
24608     PyObject *_res = NULL;
24609     ComponentResult _rv;
24610     MediaHandler mh;
24611     ComponentInstance vout;
24612 #ifndef MediaVideoOutputChanged
24613     PyMac_PRECHECK(MediaVideoOutputChanged);
24614 #endif
24615     if (!PyArg_ParseTuple(_args, "O&O&",
24616                           CmpInstObj_Convert, &mh,
24617                           CmpInstObj_Convert, &vout))
24618         return NULL;
24619     _rv = MediaVideoOutputChanged(mh,
24620                                   vout);
24621     _res = Py_BuildValue("l",
24622                          _rv);
24623     return _res;
24624 }
24625
24626 static PyObject *Qt_MediaEmptySampleCache(PyObject *_self, PyObject *_args)
24627 {
24628     PyObject *_res = NULL;
24629     ComponentResult _rv;
24630     MediaHandler mh;
24631     long sampleNum;
24632     long sampleCount;
24633 #ifndef MediaEmptySampleCache
24634     PyMac_PRECHECK(MediaEmptySampleCache);
24635 #endif
24636     if (!PyArg_ParseTuple(_args, "O&ll",
24637                           CmpInstObj_Convert, &mh,
24638                           &sampleNum,
24639                           &sampleCount))
24640         return NULL;
24641     _rv = MediaEmptySampleCache(mh,
24642                                 sampleNum,
24643                                 sampleCount);
24644     _res = Py_BuildValue("l",
24645                          _rv);
24646     return _res;
24647 }
24648
24649 static PyObject *Qt_MediaGetPublicInfo(PyObject *_self, PyObject *_args)
24650 {
24651     PyObject *_res = NULL;
24652     ComponentResult _rv;
24653     MediaHandler mh;
24654     OSType infoSelector;
24655     void * infoDataPtr;
24656     Size ioDataSize;
24657 #ifndef MediaGetPublicInfo
24658     PyMac_PRECHECK(MediaGetPublicInfo);
24659 #endif
24660     if (!PyArg_ParseTuple(_args, "O&O&s",
24661                           CmpInstObj_Convert, &mh,
24662                           PyMac_GetOSType, &infoSelector,
24663                           &infoDataPtr))
24664         return NULL;
24665     _rv = MediaGetPublicInfo(mh,
24666                              infoSelector,
24667                              infoDataPtr,
24668                              &ioDataSize);
24669     _res = Py_BuildValue("ll",
24670                          _rv,
24671                          ioDataSize);
24672     return _res;
24673 }
24674
24675 static PyObject *Qt_MediaSetPublicInfo(PyObject *_self, PyObject *_args)
24676 {
24677     PyObject *_res = NULL;
24678     ComponentResult _rv;
24679     MediaHandler mh;
24680     OSType infoSelector;
24681     void * infoDataPtr;
24682     Size dataSize;
24683 #ifndef MediaSetPublicInfo
24684     PyMac_PRECHECK(MediaSetPublicInfo);
24685 #endif
24686     if (!PyArg_ParseTuple(_args, "O&O&sl",
24687                           CmpInstObj_Convert, &mh,
24688                           PyMac_GetOSType, &infoSelector,
24689                           &infoDataPtr,
24690                           &dataSize))
24691         return NULL;
24692     _rv = MediaSetPublicInfo(mh,
24693                              infoSelector,
24694                              infoDataPtr,
24695                              dataSize);
24696     _res = Py_BuildValue("l",
24697                          _rv);
24698     return _res;
24699 }
24700
24701 static PyObject *Qt_MediaRefConSetProperty(PyObject *_self, PyObject *_args)
24702 {
24703     PyObject *_res = NULL;
24704     ComponentResult _rv;
24705     MediaHandler mh;
24706     long refCon;
24707     long propertyType;
24708     void * propertyValue;
24709 #ifndef MediaRefConSetProperty
24710     PyMac_PRECHECK(MediaRefConSetProperty);
24711 #endif
24712     if (!PyArg_ParseTuple(_args, "O&lls",
24713                           CmpInstObj_Convert, &mh,
24714                           &refCon,
24715                           &propertyType,
24716                           &propertyValue))
24717         return NULL;
24718     _rv = MediaRefConSetProperty(mh,
24719                                  refCon,
24720                                  propertyType,
24721                                  propertyValue);
24722     _res = Py_BuildValue("l",
24723                          _rv);
24724     return _res;
24725 }
24726
24727 static PyObject *Qt_MediaRefConGetProperty(PyObject *_self, PyObject *_args)
24728 {
24729     PyObject *_res = NULL;
24730     ComponentResult _rv;
24731     MediaHandler mh;
24732     long refCon;
24733     long propertyType;
24734     void * propertyValue;
24735 #ifndef MediaRefConGetProperty
24736     PyMac_PRECHECK(MediaRefConGetProperty);
24737 #endif
24738     if (!PyArg_ParseTuple(_args, "O&lls",
24739                           CmpInstObj_Convert, &mh,
24740                           &refCon,
24741                           &propertyType,
24742                           &propertyValue))
24743         return NULL;
24744     _rv = MediaRefConGetProperty(mh,
24745                                  refCon,
24746                                  propertyType,
24747                                  propertyValue);
24748     _res = Py_BuildValue("l",
24749                          _rv);
24750     return _res;
24751 }
24752
24753 static PyObject *Qt_MediaNavigateTargetRefCon(PyObject *_self, PyObject *_args)
24754 {
24755     PyObject *_res = NULL;
24756     ComponentResult _rv;
24757     MediaHandler mh;
24758     long navigation;
24759     long refCon;
24760 #ifndef MediaNavigateTargetRefCon
24761     PyMac_PRECHECK(MediaNavigateTargetRefCon);
24762 #endif
24763     if (!PyArg_ParseTuple(_args, "O&l",
24764                           CmpInstObj_Convert, &mh,
24765                           &navigation))
24766         return NULL;
24767     _rv = MediaNavigateTargetRefCon(mh,
24768                                     navigation,
24769                                     &refCon);
24770     _res = Py_BuildValue("ll",
24771                          _rv,
24772                          refCon);
24773     return _res;
24774 }
24775
24776 static PyObject *Qt_MediaGGetIdleManager(PyObject *_self, PyObject *_args)
24777 {
24778     PyObject *_res = NULL;
24779     ComponentResult _rv;
24780     MediaHandler mh;
24781     IdleManager pim;
24782 #ifndef MediaGGetIdleManager
24783     PyMac_PRECHECK(MediaGGetIdleManager);
24784 #endif
24785     if (!PyArg_ParseTuple(_args, "O&",
24786                           CmpInstObj_Convert, &mh))
24787         return NULL;
24788     _rv = MediaGGetIdleManager(mh,
24789                                &pim);
24790     _res = Py_BuildValue("lO&",
24791                          _rv,
24792                          IdleManagerObj_New, pim);
24793     return _res;
24794 }
24795
24796 static PyObject *Qt_MediaGSetIdleManager(PyObject *_self, PyObject *_args)
24797 {
24798     PyObject *_res = NULL;
24799     ComponentResult _rv;
24800     MediaHandler mh;
24801     IdleManager im;
24802 #ifndef MediaGSetIdleManager
24803     PyMac_PRECHECK(MediaGSetIdleManager);
24804 #endif
24805     if (!PyArg_ParseTuple(_args, "O&O&",
24806                           CmpInstObj_Convert, &mh,
24807                           IdleManagerObj_Convert, &im))
24808         return NULL;
24809     _rv = MediaGSetIdleManager(mh,
24810                                im);
24811     _res = Py_BuildValue("l",
24812                          _rv);
24813     return _res;
24814 }
24815
24816 static PyObject *Qt_QTMIDIGetMIDIPorts(PyObject *_self, PyObject *_args)
24817 {
24818     PyObject *_res = NULL;
24819     ComponentResult _rv;
24820     QTMIDIComponent ci;
24821     QTMIDIPortListHandle inputPorts;
24822     QTMIDIPortListHandle outputPorts;
24823 #ifndef QTMIDIGetMIDIPorts
24824     PyMac_PRECHECK(QTMIDIGetMIDIPorts);
24825 #endif
24826     if (!PyArg_ParseTuple(_args, "O&",
24827                           CmpInstObj_Convert, &ci))
24828         return NULL;
24829     _rv = QTMIDIGetMIDIPorts(ci,
24830                              &inputPorts,
24831                              &outputPorts);
24832     _res = Py_BuildValue("lO&O&",
24833                          _rv,
24834                          ResObj_New, inputPorts,
24835                          ResObj_New, outputPorts);
24836     return _res;
24837 }
24838
24839 static PyObject *Qt_QTMIDIUseSendPort(PyObject *_self, PyObject *_args)
24840 {
24841     PyObject *_res = NULL;
24842     ComponentResult _rv;
24843     QTMIDIComponent ci;
24844     long portIndex;
24845     long inUse;
24846 #ifndef QTMIDIUseSendPort
24847     PyMac_PRECHECK(QTMIDIUseSendPort);
24848 #endif
24849     if (!PyArg_ParseTuple(_args, "O&ll",
24850                           CmpInstObj_Convert, &ci,
24851                           &portIndex,
24852                           &inUse))
24853         return NULL;
24854     _rv = QTMIDIUseSendPort(ci,
24855                             portIndex,
24856                             inUse);
24857     _res = Py_BuildValue("l",
24858                          _rv);
24859     return _res;
24860 }
24861
24862 static PyObject *Qt_QTMIDISendMIDI(PyObject *_self, PyObject *_args)
24863 {
24864     PyObject *_res = NULL;
24865     ComponentResult _rv;
24866     QTMIDIComponent ci;
24867     long portIndex;
24868     MusicMIDIPacket mp;
24869 #ifndef QTMIDISendMIDI
24870     PyMac_PRECHECK(QTMIDISendMIDI);
24871 #endif
24872     if (!PyArg_ParseTuple(_args, "O&lO&",
24873                           CmpInstObj_Convert, &ci,
24874                           &portIndex,
24875                           QtMusicMIDIPacket_Convert, &mp))
24876         return NULL;
24877     _rv = QTMIDISendMIDI(ci,
24878                          portIndex,
24879                          &mp);
24880     _res = Py_BuildValue("l",
24881                          _rv);
24882     return _res;
24883 }
24884
24885 static PyObject *Qt_MusicGetPart(PyObject *_self, PyObject *_args)
24886 {
24887     PyObject *_res = NULL;
24888     ComponentResult _rv;
24889     MusicComponent mc;
24890     long part;
24891     long midiChannel;
24892     long polyphony;
24893 #ifndef MusicGetPart
24894     PyMac_PRECHECK(MusicGetPart);
24895 #endif
24896     if (!PyArg_ParseTuple(_args, "O&l",
24897                           CmpInstObj_Convert, &mc,
24898                           &part))
24899         return NULL;
24900     _rv = MusicGetPart(mc,
24901                        part,
24902                        &midiChannel,
24903                        &polyphony);
24904     _res = Py_BuildValue("lll",
24905                          _rv,
24906                          midiChannel,
24907                          polyphony);
24908     return _res;
24909 }
24910
24911 static PyObject *Qt_MusicSetPart(PyObject *_self, PyObject *_args)
24912 {
24913     PyObject *_res = NULL;
24914     ComponentResult _rv;
24915     MusicComponent mc;
24916     long part;
24917     long midiChannel;
24918     long polyphony;
24919 #ifndef MusicSetPart
24920     PyMac_PRECHECK(MusicSetPart);
24921 #endif
24922     if (!PyArg_ParseTuple(_args, "O&lll",
24923                           CmpInstObj_Convert, &mc,
24924                           &part,
24925                           &midiChannel,
24926                           &polyphony))
24927         return NULL;
24928     _rv = MusicSetPart(mc,
24929                        part,
24930                        midiChannel,
24931                        polyphony);
24932     _res = Py_BuildValue("l",
24933                          _rv);
24934     return _res;
24935 }
24936
24937 static PyObject *Qt_MusicSetPartInstrumentNumber(PyObject *_self, PyObject *_args)
24938 {
24939     PyObject *_res = NULL;
24940     ComponentResult _rv;
24941     MusicComponent mc;
24942     long part;
24943     long instrumentNumber;
24944 #ifndef MusicSetPartInstrumentNumber
24945     PyMac_PRECHECK(MusicSetPartInstrumentNumber);
24946 #endif
24947     if (!PyArg_ParseTuple(_args, "O&ll",
24948                           CmpInstObj_Convert, &mc,
24949                           &part,
24950                           &instrumentNumber))
24951         return NULL;
24952     _rv = MusicSetPartInstrumentNumber(mc,
24953                                        part,
24954                                        instrumentNumber);
24955     _res = Py_BuildValue("l",
24956                          _rv);
24957     return _res;
24958 }
24959
24960 static PyObject *Qt_MusicGetPartInstrumentNumber(PyObject *_self, PyObject *_args)
24961 {
24962     PyObject *_res = NULL;
24963     ComponentResult _rv;
24964     MusicComponent mc;
24965     long part;
24966 #ifndef MusicGetPartInstrumentNumber
24967     PyMac_PRECHECK(MusicGetPartInstrumentNumber);
24968 #endif
24969     if (!PyArg_ParseTuple(_args, "O&l",
24970                           CmpInstObj_Convert, &mc,
24971                           &part))
24972         return NULL;
24973     _rv = MusicGetPartInstrumentNumber(mc,
24974                                        part);
24975     _res = Py_BuildValue("l",
24976                          _rv);
24977     return _res;
24978 }
24979
24980 static PyObject *Qt_MusicStorePartInstrument(PyObject *_self, PyObject *_args)
24981 {
24982     PyObject *_res = NULL;
24983     ComponentResult _rv;
24984     MusicComponent mc;
24985     long part;
24986     long instrumentNumber;
24987 #ifndef MusicStorePartInstrument
24988     PyMac_PRECHECK(MusicStorePartInstrument);
24989 #endif
24990     if (!PyArg_ParseTuple(_args, "O&ll",
24991                           CmpInstObj_Convert, &mc,
24992                           &part,
24993                           &instrumentNumber))
24994         return NULL;
24995     _rv = MusicStorePartInstrument(mc,
24996                                    part,
24997                                    instrumentNumber);
24998     _res = Py_BuildValue("l",
24999                          _rv);
25000     return _res;
25001 }
25002
25003 static PyObject *Qt_MusicGetPartAtomicInstrument(PyObject *_self, PyObject *_args)
25004 {
25005     PyObject *_res = NULL;
25006     ComponentResult _rv;
25007     MusicComponent mc;
25008     long part;
25009     AtomicInstrument ai;
25010     long flags;
25011 #ifndef MusicGetPartAtomicInstrument
25012     PyMac_PRECHECK(MusicGetPartAtomicInstrument);
25013 #endif
25014     if (!PyArg_ParseTuple(_args, "O&ll",
25015                           CmpInstObj_Convert, &mc,
25016                           &part,
25017                           &flags))
25018         return NULL;
25019     _rv = MusicGetPartAtomicInstrument(mc,
25020                                        part,
25021                                        &ai,
25022                                        flags);
25023     _res = Py_BuildValue("lO&",
25024                          _rv,
25025                          ResObj_New, ai);
25026     return _res;
25027 }
25028
25029 static PyObject *Qt_MusicSetPartAtomicInstrument(PyObject *_self, PyObject *_args)
25030 {
25031     PyObject *_res = NULL;
25032     ComponentResult _rv;
25033     MusicComponent mc;
25034     long part;
25035     AtomicInstrumentPtr aiP;
25036     long flags;
25037 #ifndef MusicSetPartAtomicInstrument
25038     PyMac_PRECHECK(MusicSetPartAtomicInstrument);
25039 #endif
25040     if (!PyArg_ParseTuple(_args, "O&lsl",
25041                           CmpInstObj_Convert, &mc,
25042                           &part,
25043                           &aiP,
25044                           &flags))
25045         return NULL;
25046     _rv = MusicSetPartAtomicInstrument(mc,
25047                                        part,
25048                                        aiP,
25049                                        flags);
25050     _res = Py_BuildValue("l",
25051                          _rv);
25052     return _res;
25053 }
25054
25055 static PyObject *Qt_MusicGetPartKnob(PyObject *_self, PyObject *_args)
25056 {
25057     PyObject *_res = NULL;
25058     ComponentResult _rv;
25059     MusicComponent mc;
25060     long part;
25061     long knobID;
25062 #ifndef MusicGetPartKnob
25063     PyMac_PRECHECK(MusicGetPartKnob);
25064 #endif
25065     if (!PyArg_ParseTuple(_args, "O&ll",
25066                           CmpInstObj_Convert, &mc,
25067                           &part,
25068                           &knobID))
25069         return NULL;
25070     _rv = MusicGetPartKnob(mc,
25071                            part,
25072                            knobID);
25073     _res = Py_BuildValue("l",
25074                          _rv);
25075     return _res;
25076 }
25077
25078 static PyObject *Qt_MusicSetPartKnob(PyObject *_self, PyObject *_args)
25079 {
25080     PyObject *_res = NULL;
25081     ComponentResult _rv;
25082     MusicComponent mc;
25083     long part;
25084     long knobID;
25085     long knobValue;
25086 #ifndef MusicSetPartKnob
25087     PyMac_PRECHECK(MusicSetPartKnob);
25088 #endif
25089     if (!PyArg_ParseTuple(_args, "O&lll",
25090                           CmpInstObj_Convert, &mc,
25091                           &part,
25092                           &knobID,
25093                           &knobValue))
25094         return NULL;
25095     _rv = MusicSetPartKnob(mc,
25096                            part,
25097                            knobID,
25098                            knobValue);
25099     _res = Py_BuildValue("l",
25100                          _rv);
25101     return _res;
25102 }
25103
25104 static PyObject *Qt_MusicGetKnob(PyObject *_self, PyObject *_args)
25105 {
25106     PyObject *_res = NULL;
25107     ComponentResult _rv;
25108     MusicComponent mc;
25109     long knobID;
25110 #ifndef MusicGetKnob
25111     PyMac_PRECHECK(MusicGetKnob);
25112 #endif
25113     if (!PyArg_ParseTuple(_args, "O&l",
25114                           CmpInstObj_Convert, &mc,
25115                           &knobID))
25116         return NULL;
25117     _rv = MusicGetKnob(mc,
25118                        knobID);
25119     _res = Py_BuildValue("l",
25120                          _rv);
25121     return _res;
25122 }
25123
25124 static PyObject *Qt_MusicSetKnob(PyObject *_self, PyObject *_args)
25125 {
25126     PyObject *_res = NULL;
25127     ComponentResult _rv;
25128     MusicComponent mc;
25129     long knobID;
25130     long knobValue;
25131 #ifndef MusicSetKnob
25132     PyMac_PRECHECK(MusicSetKnob);
25133 #endif
25134     if (!PyArg_ParseTuple(_args, "O&ll",
25135                           CmpInstObj_Convert, &mc,
25136                           &knobID,
25137                           &knobValue))
25138         return NULL;
25139     _rv = MusicSetKnob(mc,
25140                        knobID,
25141                        knobValue);
25142     _res = Py_BuildValue("l",
25143                          _rv);
25144     return _res;
25145 }
25146
25147 static PyObject *Qt_MusicGetPartName(PyObject *_self, PyObject *_args)
25148 {
25149     PyObject *_res = NULL;
25150     ComponentResult _rv;
25151     MusicComponent mc;
25152     long part;
25153     StringPtr name;
25154 #ifndef MusicGetPartName
25155     PyMac_PRECHECK(MusicGetPartName);
25156 #endif
25157     if (!PyArg_ParseTuple(_args, "O&ls",
25158                           CmpInstObj_Convert, &mc,
25159                           &part,
25160                           &name))
25161         return NULL;
25162     _rv = MusicGetPartName(mc,
25163                            part,
25164                            name);
25165     _res = Py_BuildValue("l",
25166                          _rv);
25167     return _res;
25168 }
25169
25170 static PyObject *Qt_MusicSetPartName(PyObject *_self, PyObject *_args)
25171 {
25172     PyObject *_res = NULL;
25173     ComponentResult _rv;
25174     MusicComponent mc;
25175     long part;
25176     StringPtr name;
25177 #ifndef MusicSetPartName
25178     PyMac_PRECHECK(MusicSetPartName);
25179 #endif
25180     if (!PyArg_ParseTuple(_args, "O&ls",
25181                           CmpInstObj_Convert, &mc,
25182                           &part,
25183                           &name))
25184         return NULL;
25185     _rv = MusicSetPartName(mc,
25186                            part,
25187                            name);
25188     _res = Py_BuildValue("l",
25189                          _rv);
25190     return _res;
25191 }
25192
25193 static PyObject *Qt_MusicPlayNote(PyObject *_self, PyObject *_args)
25194 {
25195     PyObject *_res = NULL;
25196     ComponentResult _rv;
25197     MusicComponent mc;
25198     long part;
25199     long pitch;
25200     long velocity;
25201 #ifndef MusicPlayNote
25202     PyMac_PRECHECK(MusicPlayNote);
25203 #endif
25204     if (!PyArg_ParseTuple(_args, "O&lll",
25205                           CmpInstObj_Convert, &mc,
25206                           &part,
25207                           &pitch,
25208                           &velocity))
25209         return NULL;
25210     _rv = MusicPlayNote(mc,
25211                         part,
25212                         pitch,
25213                         velocity);
25214     _res = Py_BuildValue("l",
25215                          _rv);
25216     return _res;
25217 }
25218
25219 static PyObject *Qt_MusicResetPart(PyObject *_self, PyObject *_args)
25220 {
25221     PyObject *_res = NULL;
25222     ComponentResult _rv;
25223     MusicComponent mc;
25224     long part;
25225 #ifndef MusicResetPart
25226     PyMac_PRECHECK(MusicResetPart);
25227 #endif
25228     if (!PyArg_ParseTuple(_args, "O&l",
25229                           CmpInstObj_Convert, &mc,
25230                           &part))
25231         return NULL;
25232     _rv = MusicResetPart(mc,
25233                          part);
25234     _res = Py_BuildValue("l",
25235                          _rv);
25236     return _res;
25237 }
25238
25239 static PyObject *Qt_MusicSetPartController(PyObject *_self, PyObject *_args)
25240 {
25241     PyObject *_res = NULL;
25242     ComponentResult _rv;
25243     MusicComponent mc;
25244     long part;
25245     MusicController controllerNumber;
25246     long controllerValue;
25247 #ifndef MusicSetPartController
25248     PyMac_PRECHECK(MusicSetPartController);
25249 #endif
25250     if (!PyArg_ParseTuple(_args, "O&lll",
25251                           CmpInstObj_Convert, &mc,
25252                           &part,
25253                           &controllerNumber,
25254                           &controllerValue))
25255         return NULL;
25256     _rv = MusicSetPartController(mc,
25257                                  part,
25258                                  controllerNumber,
25259                                  controllerValue);
25260     _res = Py_BuildValue("l",
25261                          _rv);
25262     return _res;
25263 }
25264
25265 static PyObject *Qt_MusicGetPartController(PyObject *_self, PyObject *_args)
25266 {
25267     PyObject *_res = NULL;
25268     ComponentResult _rv;
25269     MusicComponent mc;
25270     long part;
25271     MusicController controllerNumber;
25272 #ifndef MusicGetPartController
25273     PyMac_PRECHECK(MusicGetPartController);
25274 #endif
25275     if (!PyArg_ParseTuple(_args, "O&ll",
25276                           CmpInstObj_Convert, &mc,
25277                           &part,
25278                           &controllerNumber))
25279         return NULL;
25280     _rv = MusicGetPartController(mc,
25281                                  part,
25282                                  controllerNumber);
25283     _res = Py_BuildValue("l",
25284                          _rv);
25285     return _res;
25286 }
25287
25288 static PyObject *Qt_MusicGetInstrumentNames(PyObject *_self, PyObject *_args)
25289 {
25290     PyObject *_res = NULL;
25291     ComponentResult _rv;
25292     MusicComponent mc;
25293     long modifiableInstruments;
25294     Handle instrumentNames;
25295     Handle instrumentCategoryLasts;
25296     Handle instrumentCategoryNames;
25297 #ifndef MusicGetInstrumentNames
25298     PyMac_PRECHECK(MusicGetInstrumentNames);
25299 #endif
25300     if (!PyArg_ParseTuple(_args, "O&l",
25301                           CmpInstObj_Convert, &mc,
25302                           &modifiableInstruments))
25303         return NULL;
25304     _rv = MusicGetInstrumentNames(mc,
25305                                   modifiableInstruments,
25306                                   &instrumentNames,
25307                                   &instrumentCategoryLasts,
25308                                   &instrumentCategoryNames);
25309     _res = Py_BuildValue("lO&O&O&",
25310                          _rv,
25311                          ResObj_New, instrumentNames,
25312                          ResObj_New, instrumentCategoryLasts,
25313                          ResObj_New, instrumentCategoryNames);
25314     return _res;
25315 }
25316
25317 static PyObject *Qt_MusicGetDrumNames(PyObject *_self, PyObject *_args)
25318 {
25319     PyObject *_res = NULL;
25320     ComponentResult _rv;
25321     MusicComponent mc;
25322     long modifiableInstruments;
25323     Handle instrumentNumbers;
25324     Handle instrumentNames;
25325 #ifndef MusicGetDrumNames
25326     PyMac_PRECHECK(MusicGetDrumNames);
25327 #endif
25328     if (!PyArg_ParseTuple(_args, "O&l",
25329                           CmpInstObj_Convert, &mc,
25330                           &modifiableInstruments))
25331         return NULL;
25332     _rv = MusicGetDrumNames(mc,
25333                             modifiableInstruments,
25334                             &instrumentNumbers,
25335                             &instrumentNames);
25336     _res = Py_BuildValue("lO&O&",
25337                          _rv,
25338                          ResObj_New, instrumentNumbers,
25339                          ResObj_New, instrumentNames);
25340     return _res;
25341 }
25342
25343 static PyObject *Qt_MusicGetMasterTune(PyObject *_self, PyObject *_args)
25344 {
25345     PyObject *_res = NULL;
25346     ComponentResult _rv;
25347     MusicComponent mc;
25348 #ifndef MusicGetMasterTune
25349     PyMac_PRECHECK(MusicGetMasterTune);
25350 #endif
25351     if (!PyArg_ParseTuple(_args, "O&",
25352                           CmpInstObj_Convert, &mc))
25353         return NULL;
25354     _rv = MusicGetMasterTune(mc);
25355     _res = Py_BuildValue("l",
25356                          _rv);
25357     return _res;
25358 }
25359
25360 static PyObject *Qt_MusicSetMasterTune(PyObject *_self, PyObject *_args)
25361 {
25362     PyObject *_res = NULL;
25363     ComponentResult _rv;
25364     MusicComponent mc;
25365     long masterTune;
25366 #ifndef MusicSetMasterTune
25367     PyMac_PRECHECK(MusicSetMasterTune);
25368 #endif
25369     if (!PyArg_ParseTuple(_args, "O&l",
25370                           CmpInstObj_Convert, &mc,
25371                           &masterTune))
25372         return NULL;
25373     _rv = MusicSetMasterTune(mc,
25374                              masterTune);
25375     _res = Py_BuildValue("l",
25376                          _rv);
25377     return _res;
25378 }
25379
25380 static PyObject *Qt_MusicGetDeviceConnection(PyObject *_self, PyObject *_args)
25381 {
25382     PyObject *_res = NULL;
25383     ComponentResult _rv;
25384     MusicComponent mc;
25385     long index;
25386     long id1;
25387     long id2;
25388 #ifndef MusicGetDeviceConnection
25389     PyMac_PRECHECK(MusicGetDeviceConnection);
25390 #endif
25391     if (!PyArg_ParseTuple(_args, "O&l",
25392                           CmpInstObj_Convert, &mc,
25393                           &index))
25394         return NULL;
25395     _rv = MusicGetDeviceConnection(mc,
25396                                    index,
25397                                    &id1,
25398                                    &id2);
25399     _res = Py_BuildValue("lll",
25400                          _rv,
25401                          id1,
25402                          id2);
25403     return _res;
25404 }
25405
25406 static PyObject *Qt_MusicUseDeviceConnection(PyObject *_self, PyObject *_args)
25407 {
25408     PyObject *_res = NULL;
25409     ComponentResult _rv;
25410     MusicComponent mc;
25411     long id1;
25412     long id2;
25413 #ifndef MusicUseDeviceConnection
25414     PyMac_PRECHECK(MusicUseDeviceConnection);
25415 #endif
25416     if (!PyArg_ParseTuple(_args, "O&ll",
25417                           CmpInstObj_Convert, &mc,
25418                           &id1,
25419                           &id2))
25420         return NULL;
25421     _rv = MusicUseDeviceConnection(mc,
25422                                    id1,
25423                                    id2);
25424     _res = Py_BuildValue("l",
25425                          _rv);
25426     return _res;
25427 }
25428
25429 static PyObject *Qt_MusicGetKnobSettingStrings(PyObject *_self, PyObject *_args)
25430 {
25431     PyObject *_res = NULL;
25432     ComponentResult _rv;
25433     MusicComponent mc;
25434     long knobIndex;
25435     long isGlobal;
25436     Handle settingsNames;
25437     Handle settingsCategoryLasts;
25438     Handle settingsCategoryNames;
25439 #ifndef MusicGetKnobSettingStrings
25440     PyMac_PRECHECK(MusicGetKnobSettingStrings);
25441 #endif
25442     if (!PyArg_ParseTuple(_args, "O&ll",
25443                           CmpInstObj_Convert, &mc,
25444                           &knobIndex,
25445                           &isGlobal))
25446         return NULL;
25447     _rv = MusicGetKnobSettingStrings(mc,
25448                                      knobIndex,
25449                                      isGlobal,
25450                                      &settingsNames,
25451                                      &settingsCategoryLasts,
25452                                      &settingsCategoryNames);
25453     _res = Py_BuildValue("lO&O&O&",
25454                          _rv,
25455                          ResObj_New, settingsNames,
25456                          ResObj_New, settingsCategoryLasts,
25457                          ResObj_New, settingsCategoryNames);
25458     return _res;
25459 }
25460
25461 static PyObject *Qt_MusicGetMIDIPorts(PyObject *_self, PyObject *_args)
25462 {
25463     PyObject *_res = NULL;
25464     ComponentResult _rv;
25465     MusicComponent mc;
25466     long inputPortCount;
25467     long outputPortCount;
25468 #ifndef MusicGetMIDIPorts
25469     PyMac_PRECHECK(MusicGetMIDIPorts);
25470 #endif
25471     if (!PyArg_ParseTuple(_args, "O&",
25472                           CmpInstObj_Convert, &mc))
25473         return NULL;
25474     _rv = MusicGetMIDIPorts(mc,
25475                             &inputPortCount,
25476                             &outputPortCount);
25477     _res = Py_BuildValue("lll",
25478                          _rv,
25479                          inputPortCount,
25480                          outputPortCount);
25481     return _res;
25482 }
25483
25484 static PyObject *Qt_MusicSendMIDI(PyObject *_self, PyObject *_args)
25485 {
25486     PyObject *_res = NULL;
25487     ComponentResult _rv;
25488     MusicComponent mc;
25489     long portIndex;
25490     MusicMIDIPacket mp;
25491 #ifndef MusicSendMIDI
25492     PyMac_PRECHECK(MusicSendMIDI);
25493 #endif
25494     if (!PyArg_ParseTuple(_args, "O&lO&",
25495                           CmpInstObj_Convert, &mc,
25496                           &portIndex,
25497                           QtMusicMIDIPacket_Convert, &mp))
25498         return NULL;
25499     _rv = MusicSendMIDI(mc,
25500                         portIndex,
25501                         &mp);
25502     _res = Py_BuildValue("l",
25503                          _rv);
25504     return _res;
25505 }
25506
25507 static PyObject *Qt_MusicSetOfflineTimeTo(PyObject *_self, PyObject *_args)
25508 {
25509     PyObject *_res = NULL;
25510     ComponentResult _rv;
25511     MusicComponent mc;
25512     long newTimeStamp;
25513 #ifndef MusicSetOfflineTimeTo
25514     PyMac_PRECHECK(MusicSetOfflineTimeTo);
25515 #endif
25516     if (!PyArg_ParseTuple(_args, "O&l",
25517                           CmpInstObj_Convert, &mc,
25518                           &newTimeStamp))
25519         return NULL;
25520     _rv = MusicSetOfflineTimeTo(mc,
25521                                 newTimeStamp);
25522     _res = Py_BuildValue("l",
25523                          _rv);
25524     return _res;
25525 }
25526
25527 static PyObject *Qt_MusicGetInfoText(PyObject *_self, PyObject *_args)
25528 {
25529     PyObject *_res = NULL;
25530     ComponentResult _rv;
25531     MusicComponent mc;
25532     long selector;
25533     Handle textH;
25534     Handle styleH;
25535 #ifndef MusicGetInfoText
25536     PyMac_PRECHECK(MusicGetInfoText);
25537 #endif
25538     if (!PyArg_ParseTuple(_args, "O&l",
25539                           CmpInstObj_Convert, &mc,
25540                           &selector))
25541         return NULL;
25542     _rv = MusicGetInfoText(mc,
25543                            selector,
25544                            &textH,
25545                            &styleH);
25546     _res = Py_BuildValue("lO&O&",
25547                          _rv,
25548                          ResObj_New, textH,
25549                          ResObj_New, styleH);
25550     return _res;
25551 }
25552
25553 static PyObject *Qt_MusicGetInstrumentInfo(PyObject *_self, PyObject *_args)
25554 {
25555     PyObject *_res = NULL;
25556     ComponentResult _rv;
25557     MusicComponent mc;
25558     long getInstrumentInfoFlags;
25559     InstrumentInfoListHandle infoListH;
25560 #ifndef MusicGetInstrumentInfo
25561     PyMac_PRECHECK(MusicGetInstrumentInfo);
25562 #endif
25563     if (!PyArg_ParseTuple(_args, "O&l",
25564                           CmpInstObj_Convert, &mc,
25565                           &getInstrumentInfoFlags))
25566         return NULL;
25567     _rv = MusicGetInstrumentInfo(mc,
25568                                  getInstrumentInfoFlags,
25569                                  &infoListH);
25570     _res = Py_BuildValue("lO&",
25571                          _rv,
25572                          ResObj_New, infoListH);
25573     return _res;
25574 }
25575
25576 static PyObject *Qt_MusicTask(PyObject *_self, PyObject *_args)
25577 {
25578     PyObject *_res = NULL;
25579     ComponentResult _rv;
25580     MusicComponent mc;
25581 #ifndef MusicTask
25582     PyMac_PRECHECK(MusicTask);
25583 #endif
25584     if (!PyArg_ParseTuple(_args, "O&",
25585                           CmpInstObj_Convert, &mc))
25586         return NULL;
25587     _rv = MusicTask(mc);
25588     _res = Py_BuildValue("l",
25589                          _rv);
25590     return _res;
25591 }
25592
25593 static PyObject *Qt_MusicSetPartInstrumentNumberInterruptSafe(PyObject *_self, PyObject *_args)
25594 {
25595     PyObject *_res = NULL;
25596     ComponentResult _rv;
25597     MusicComponent mc;
25598     long part;
25599     long instrumentNumber;
25600 #ifndef MusicSetPartInstrumentNumberInterruptSafe
25601     PyMac_PRECHECK(MusicSetPartInstrumentNumberInterruptSafe);
25602 #endif
25603     if (!PyArg_ParseTuple(_args, "O&ll",
25604                           CmpInstObj_Convert, &mc,
25605                           &part,
25606                           &instrumentNumber))
25607         return NULL;
25608     _rv = MusicSetPartInstrumentNumberInterruptSafe(mc,
25609                                                     part,
25610                                                     instrumentNumber);
25611     _res = Py_BuildValue("l",
25612                          _rv);
25613     return _res;
25614 }
25615
25616 static PyObject *Qt_MusicSetPartSoundLocalization(PyObject *_self, PyObject *_args)
25617 {
25618     PyObject *_res = NULL;
25619     ComponentResult _rv;
25620     MusicComponent mc;
25621     long part;
25622     Handle data;
25623 #ifndef MusicSetPartSoundLocalization
25624     PyMac_PRECHECK(MusicSetPartSoundLocalization);
25625 #endif
25626     if (!PyArg_ParseTuple(_args, "O&lO&",
25627                           CmpInstObj_Convert, &mc,
25628                           &part,
25629                           ResObj_Convert, &data))
25630         return NULL;
25631     _rv = MusicSetPartSoundLocalization(mc,
25632                                         part,
25633                                         data);
25634     _res = Py_BuildValue("l",
25635                          _rv);
25636     return _res;
25637 }
25638
25639 static PyObject *Qt_MusicGenericConfigure(PyObject *_self, PyObject *_args)
25640 {
25641     PyObject *_res = NULL;
25642     ComponentResult _rv;
25643     MusicComponent mc;
25644     long mode;
25645     long flags;
25646     long baseResID;
25647 #ifndef MusicGenericConfigure
25648     PyMac_PRECHECK(MusicGenericConfigure);
25649 #endif
25650     if (!PyArg_ParseTuple(_args, "O&lll",
25651                           CmpInstObj_Convert, &mc,
25652                           &mode,
25653                           &flags,
25654                           &baseResID))
25655         return NULL;
25656     _rv = MusicGenericConfigure(mc,
25657                                 mode,
25658                                 flags,
25659                                 baseResID);
25660     _res = Py_BuildValue("l",
25661                          _rv);
25662     return _res;
25663 }
25664
25665 static PyObject *Qt_MusicGenericGetKnobList(PyObject *_self, PyObject *_args)
25666 {
25667     PyObject *_res = NULL;
25668     ComponentResult _rv;
25669     MusicComponent mc;
25670     long knobType;
25671     GenericKnobDescriptionListHandle gkdlH;
25672 #ifndef MusicGenericGetKnobList
25673     PyMac_PRECHECK(MusicGenericGetKnobList);
25674 #endif
25675     if (!PyArg_ParseTuple(_args, "O&l",
25676                           CmpInstObj_Convert, &mc,
25677                           &knobType))
25678         return NULL;
25679     _rv = MusicGenericGetKnobList(mc,
25680                                   knobType,
25681                                   &gkdlH);
25682     _res = Py_BuildValue("lO&",
25683                          _rv,
25684                          ResObj_New, gkdlH);
25685     return _res;
25686 }
25687
25688 static PyObject *Qt_MusicGenericSetResourceNumbers(PyObject *_self, PyObject *_args)
25689 {
25690     PyObject *_res = NULL;
25691     ComponentResult _rv;
25692     MusicComponent mc;
25693     Handle resourceIDH;
25694 #ifndef MusicGenericSetResourceNumbers
25695     PyMac_PRECHECK(MusicGenericSetResourceNumbers);
25696 #endif
25697     if (!PyArg_ParseTuple(_args, "O&O&",
25698                           CmpInstObj_Convert, &mc,
25699                           ResObj_Convert, &resourceIDH))
25700         return NULL;
25701     _rv = MusicGenericSetResourceNumbers(mc,
25702                                          resourceIDH);
25703     _res = Py_BuildValue("l",
25704                          _rv);
25705     return _res;
25706 }
25707
25708 static PyObject *Qt_MusicDerivedMIDISend(PyObject *_self, PyObject *_args)
25709 {
25710     PyObject *_res = NULL;
25711     ComponentResult _rv;
25712     MusicComponent mc;
25713     MusicMIDIPacket packet;
25714 #ifndef MusicDerivedMIDISend
25715     PyMac_PRECHECK(MusicDerivedMIDISend);
25716 #endif
25717     if (!PyArg_ParseTuple(_args, "O&O&",
25718                           CmpInstObj_Convert, &mc,
25719                           QtMusicMIDIPacket_Convert, &packet))
25720         return NULL;
25721     _rv = MusicDerivedMIDISend(mc,
25722                                &packet);
25723     _res = Py_BuildValue("l",
25724                          _rv);
25725     return _res;
25726 }
25727
25728 static PyObject *Qt_MusicDerivedOpenResFile(PyObject *_self, PyObject *_args)
25729 {
25730     PyObject *_res = NULL;
25731     ComponentResult _rv;
25732     MusicComponent mc;
25733 #ifndef MusicDerivedOpenResFile
25734     PyMac_PRECHECK(MusicDerivedOpenResFile);
25735 #endif
25736     if (!PyArg_ParseTuple(_args, "O&",
25737                           CmpInstObj_Convert, &mc))
25738         return NULL;
25739     _rv = MusicDerivedOpenResFile(mc);
25740     _res = Py_BuildValue("l",
25741                          _rv);
25742     return _res;
25743 }
25744
25745 static PyObject *Qt_MusicDerivedCloseResFile(PyObject *_self, PyObject *_args)
25746 {
25747     PyObject *_res = NULL;
25748     ComponentResult _rv;
25749     MusicComponent mc;
25750     short resRefNum;
25751 #ifndef MusicDerivedCloseResFile
25752     PyMac_PRECHECK(MusicDerivedCloseResFile);
25753 #endif
25754     if (!PyArg_ParseTuple(_args, "O&h",
25755                           CmpInstObj_Convert, &mc,
25756                           &resRefNum))
25757         return NULL;
25758     _rv = MusicDerivedCloseResFile(mc,
25759                                    resRefNum);
25760     _res = Py_BuildValue("l",
25761                          _rv);
25762     return _res;
25763 }
25764
25765 static PyObject *Qt_NAUnregisterMusicDevice(PyObject *_self, PyObject *_args)
25766 {
25767     PyObject *_res = NULL;
25768     ComponentResult _rv;
25769     NoteAllocator na;
25770     long index;
25771 #ifndef NAUnregisterMusicDevice
25772     PyMac_PRECHECK(NAUnregisterMusicDevice);
25773 #endif
25774     if (!PyArg_ParseTuple(_args, "O&l",
25775                           CmpInstObj_Convert, &na,
25776                           &index))
25777         return NULL;
25778     _rv = NAUnregisterMusicDevice(na,
25779                                   index);
25780     _res = Py_BuildValue("l",
25781                          _rv);
25782     return _res;
25783 }
25784
25785 static PyObject *Qt_NASaveMusicConfiguration(PyObject *_self, PyObject *_args)
25786 {
25787     PyObject *_res = NULL;
25788     ComponentResult _rv;
25789     NoteAllocator na;
25790 #ifndef NASaveMusicConfiguration
25791     PyMac_PRECHECK(NASaveMusicConfiguration);
25792 #endif
25793     if (!PyArg_ParseTuple(_args, "O&",
25794                           CmpInstObj_Convert, &na))
25795         return NULL;
25796     _rv = NASaveMusicConfiguration(na);
25797     _res = Py_BuildValue("l",
25798                          _rv);
25799     return _res;
25800 }
25801
25802 static PyObject *Qt_NAGetMIDIPorts(PyObject *_self, PyObject *_args)
25803 {
25804     PyObject *_res = NULL;
25805     ComponentResult _rv;
25806     NoteAllocator na;
25807     QTMIDIPortListHandle inputPorts;
25808     QTMIDIPortListHandle outputPorts;
25809 #ifndef NAGetMIDIPorts
25810     PyMac_PRECHECK(NAGetMIDIPorts);
25811 #endif
25812     if (!PyArg_ParseTuple(_args, "O&",
25813                           CmpInstObj_Convert, &na))
25814         return NULL;
25815     _rv = NAGetMIDIPorts(na,
25816                          &inputPorts,
25817                          &outputPorts);
25818     _res = Py_BuildValue("lO&O&",
25819                          _rv,
25820                          ResObj_New, inputPorts,
25821                          ResObj_New, outputPorts);
25822     return _res;
25823 }
25824
25825 static PyObject *Qt_NATask(PyObject *_self, PyObject *_args)
25826 {
25827     PyObject *_res = NULL;
25828     ComponentResult _rv;
25829     NoteAllocator na;
25830 #ifndef NATask
25831     PyMac_PRECHECK(NATask);
25832 #endif
25833     if (!PyArg_ParseTuple(_args, "O&",
25834                           CmpInstObj_Convert, &na))
25835         return NULL;
25836     _rv = NATask(na);
25837     _res = Py_BuildValue("l",
25838                          _rv);
25839     return _res;
25840 }
25841
25842 static PyObject *Qt_TuneSetHeader(PyObject *_self, PyObject *_args)
25843 {
25844     PyObject *_res = NULL;
25845     ComponentResult _rv;
25846     TunePlayer tp;
25847     unsigned long * header;
25848 #ifndef TuneSetHeader
25849     PyMac_PRECHECK(TuneSetHeader);
25850 #endif
25851     if (!PyArg_ParseTuple(_args, "O&s",
25852                           CmpInstObj_Convert, &tp,
25853                           &header))
25854         return NULL;
25855     _rv = TuneSetHeader(tp,
25856                         header);
25857     _res = Py_BuildValue("l",
25858                          _rv);
25859     return _res;
25860 }
25861
25862 static PyObject *Qt_TuneGetTimeBase(PyObject *_self, PyObject *_args)
25863 {
25864     PyObject *_res = NULL;
25865     ComponentResult _rv;
25866     TunePlayer tp;
25867     TimeBase tb;
25868 #ifndef TuneGetTimeBase
25869     PyMac_PRECHECK(TuneGetTimeBase);
25870 #endif
25871     if (!PyArg_ParseTuple(_args, "O&",
25872                           CmpInstObj_Convert, &tp))
25873         return NULL;
25874     _rv = TuneGetTimeBase(tp,
25875                           &tb);
25876     _res = Py_BuildValue("lO&",
25877                          _rv,
25878                          TimeBaseObj_New, tb);
25879     return _res;
25880 }
25881
25882 static PyObject *Qt_TuneSetTimeScale(PyObject *_self, PyObject *_args)
25883 {
25884     PyObject *_res = NULL;
25885     ComponentResult _rv;
25886     TunePlayer tp;
25887     TimeScale scale;
25888 #ifndef TuneSetTimeScale
25889     PyMac_PRECHECK(TuneSetTimeScale);
25890 #endif
25891     if (!PyArg_ParseTuple(_args, "O&l",
25892                           CmpInstObj_Convert, &tp,
25893                           &scale))
25894         return NULL;
25895     _rv = TuneSetTimeScale(tp,
25896                            scale);
25897     _res = Py_BuildValue("l",
25898                          _rv);
25899     return _res;
25900 }
25901
25902 static PyObject *Qt_TuneGetTimeScale(PyObject *_self, PyObject *_args)
25903 {
25904     PyObject *_res = NULL;
25905     ComponentResult _rv;
25906     TunePlayer tp;
25907     TimeScale scale;
25908 #ifndef TuneGetTimeScale
25909     PyMac_PRECHECK(TuneGetTimeScale);
25910 #endif
25911     if (!PyArg_ParseTuple(_args, "O&",
25912                           CmpInstObj_Convert, &tp))
25913         return NULL;
25914     _rv = TuneGetTimeScale(tp,
25915                            &scale);
25916     _res = Py_BuildValue("ll",
25917                          _rv,
25918                          scale);
25919     return _res;
25920 }
25921
25922 static PyObject *Qt_TuneInstant(PyObject *_self, PyObject *_args)
25923 {
25924     PyObject *_res = NULL;
25925     ComponentResult _rv;
25926     TunePlayer tp;
25927     unsigned long tune;
25928     unsigned long tunePosition;
25929 #ifndef TuneInstant
25930     PyMac_PRECHECK(TuneInstant);
25931 #endif
25932     if (!PyArg_ParseTuple(_args, "O&l",
25933                           CmpInstObj_Convert, &tp,
25934                           &tunePosition))
25935         return NULL;
25936     _rv = TuneInstant(tp,
25937                       &tune,
25938                       tunePosition);
25939     _res = Py_BuildValue("ll",
25940                          _rv,
25941                          tune);
25942     return _res;
25943 }
25944
25945 static PyObject *Qt_TuneStop(PyObject *_self, PyObject *_args)
25946 {
25947     PyObject *_res = NULL;
25948     ComponentResult _rv;
25949     TunePlayer tp;
25950     long stopFlags;
25951 #ifndef TuneStop
25952     PyMac_PRECHECK(TuneStop);
25953 #endif
25954     if (!PyArg_ParseTuple(_args, "O&l",
25955                           CmpInstObj_Convert, &tp,
25956                           &stopFlags))
25957         return NULL;
25958     _rv = TuneStop(tp,
25959                    stopFlags);
25960     _res = Py_BuildValue("l",
25961                          _rv);
25962     return _res;
25963 }
25964
25965 static PyObject *Qt_TuneSetVolume(PyObject *_self, PyObject *_args)
25966 {
25967     PyObject *_res = NULL;
25968     ComponentResult _rv;
25969     TunePlayer tp;
25970     Fixed volume;
25971 #ifndef TuneSetVolume
25972     PyMac_PRECHECK(TuneSetVolume);
25973 #endif
25974     if (!PyArg_ParseTuple(_args, "O&O&",
25975                           CmpInstObj_Convert, &tp,
25976                           PyMac_GetFixed, &volume))
25977         return NULL;
25978     _rv = TuneSetVolume(tp,
25979                         volume);
25980     _res = Py_BuildValue("l",
25981                          _rv);
25982     return _res;
25983 }
25984
25985 static PyObject *Qt_TuneGetVolume(PyObject *_self, PyObject *_args)
25986 {
25987     PyObject *_res = NULL;
25988     ComponentResult _rv;
25989     TunePlayer tp;
25990 #ifndef TuneGetVolume
25991     PyMac_PRECHECK(TuneGetVolume);
25992 #endif
25993     if (!PyArg_ParseTuple(_args, "O&",
25994                           CmpInstObj_Convert, &tp))
25995         return NULL;
25996     _rv = TuneGetVolume(tp);
25997     _res = Py_BuildValue("l",
25998                          _rv);
25999     return _res;
26000 }
26001
26002 static PyObject *Qt_TunePreroll(PyObject *_self, PyObject *_args)
26003 {
26004     PyObject *_res = NULL;
26005     ComponentResult _rv;
26006     TunePlayer tp;
26007 #ifndef TunePreroll
26008     PyMac_PRECHECK(TunePreroll);
26009 #endif
26010     if (!PyArg_ParseTuple(_args, "O&",
26011                           CmpInstObj_Convert, &tp))
26012         return NULL;
26013     _rv = TunePreroll(tp);
26014     _res = Py_BuildValue("l",
26015                          _rv);
26016     return _res;
26017 }
26018
26019 static PyObject *Qt_TuneUnroll(PyObject *_self, PyObject *_args)
26020 {
26021     PyObject *_res = NULL;
26022     ComponentResult _rv;
26023     TunePlayer tp;
26024 #ifndef TuneUnroll
26025     PyMac_PRECHECK(TuneUnroll);
26026 #endif
26027     if (!PyArg_ParseTuple(_args, "O&",
26028                           CmpInstObj_Convert, &tp))
26029         return NULL;
26030     _rv = TuneUnroll(tp);
26031     _res = Py_BuildValue("l",
26032                          _rv);
26033     return _res;
26034 }
26035
26036 static PyObject *Qt_TuneSetPartTranspose(PyObject *_self, PyObject *_args)
26037 {
26038     PyObject *_res = NULL;
26039     ComponentResult _rv;
26040     TunePlayer tp;
26041     unsigned long part;
26042     long transpose;
26043     long velocityShift;
26044 #ifndef TuneSetPartTranspose
26045     PyMac_PRECHECK(TuneSetPartTranspose);
26046 #endif
26047     if (!PyArg_ParseTuple(_args, "O&lll",
26048                           CmpInstObj_Convert, &tp,
26049                           &part,
26050                           &transpose,
26051                           &velocityShift))
26052         return NULL;
26053     _rv = TuneSetPartTranspose(tp,
26054                                part,
26055                                transpose,
26056                                velocityShift);
26057     _res = Py_BuildValue("l",
26058                          _rv);
26059     return _res;
26060 }
26061
26062 static PyObject *Qt_TuneGetNoteAllocator(PyObject *_self, PyObject *_args)
26063 {
26064     PyObject *_res = NULL;
26065     NoteAllocator _rv;
26066     TunePlayer tp;
26067 #ifndef TuneGetNoteAllocator
26068     PyMac_PRECHECK(TuneGetNoteAllocator);
26069 #endif
26070     if (!PyArg_ParseTuple(_args, "O&",
26071                           CmpInstObj_Convert, &tp))
26072         return NULL;
26073     _rv = TuneGetNoteAllocator(tp);
26074     _res = Py_BuildValue("O&",
26075                          CmpInstObj_New, _rv);
26076     return _res;
26077 }
26078
26079 static PyObject *Qt_TuneSetSofter(PyObject *_self, PyObject *_args)
26080 {
26081     PyObject *_res = NULL;
26082     ComponentResult _rv;
26083     TunePlayer tp;
26084     long softer;
26085 #ifndef TuneSetSofter
26086     PyMac_PRECHECK(TuneSetSofter);
26087 #endif
26088     if (!PyArg_ParseTuple(_args, "O&l",
26089                           CmpInstObj_Convert, &tp,
26090                           &softer))
26091         return NULL;
26092     _rv = TuneSetSofter(tp,
26093                         softer);
26094     _res = Py_BuildValue("l",
26095                          _rv);
26096     return _res;
26097 }
26098
26099 static PyObject *Qt_TuneTask(PyObject *_self, PyObject *_args)
26100 {
26101     PyObject *_res = NULL;
26102     ComponentResult _rv;
26103     TunePlayer tp;
26104 #ifndef TuneTask
26105     PyMac_PRECHECK(TuneTask);
26106 #endif
26107     if (!PyArg_ParseTuple(_args, "O&",
26108                           CmpInstObj_Convert, &tp))
26109         return NULL;
26110     _rv = TuneTask(tp);
26111     _res = Py_BuildValue("l",
26112                          _rv);
26113     return _res;
26114 }
26115
26116 static PyObject *Qt_TuneSetBalance(PyObject *_self, PyObject *_args)
26117 {
26118     PyObject *_res = NULL;
26119     ComponentResult _rv;
26120     TunePlayer tp;
26121     long balance;
26122 #ifndef TuneSetBalance
26123     PyMac_PRECHECK(TuneSetBalance);
26124 #endif
26125     if (!PyArg_ParseTuple(_args, "O&l",
26126                           CmpInstObj_Convert, &tp,
26127                           &balance))
26128         return NULL;
26129     _rv = TuneSetBalance(tp,
26130                          balance);
26131     _res = Py_BuildValue("l",
26132                          _rv);
26133     return _res;
26134 }
26135
26136 static PyObject *Qt_TuneSetSoundLocalization(PyObject *_self, PyObject *_args)
26137 {
26138     PyObject *_res = NULL;
26139     ComponentResult _rv;
26140     TunePlayer tp;
26141     Handle data;
26142 #ifndef TuneSetSoundLocalization
26143     PyMac_PRECHECK(TuneSetSoundLocalization);
26144 #endif
26145     if (!PyArg_ParseTuple(_args, "O&O&",
26146                           CmpInstObj_Convert, &tp,
26147                           ResObj_Convert, &data))
26148         return NULL;
26149     _rv = TuneSetSoundLocalization(tp,
26150                                    data);
26151     _res = Py_BuildValue("l",
26152                          _rv);
26153     return _res;
26154 }
26155
26156 static PyObject *Qt_TuneSetHeaderWithSize(PyObject *_self, PyObject *_args)
26157 {
26158     PyObject *_res = NULL;
26159     ComponentResult _rv;
26160     TunePlayer tp;
26161     unsigned long * header;
26162     unsigned long size;
26163 #ifndef TuneSetHeaderWithSize
26164     PyMac_PRECHECK(TuneSetHeaderWithSize);
26165 #endif
26166     if (!PyArg_ParseTuple(_args, "O&sl",
26167                           CmpInstObj_Convert, &tp,
26168                           &header,
26169                           &size))
26170         return NULL;
26171     _rv = TuneSetHeaderWithSize(tp,
26172                                 header,
26173                                 size);
26174     _res = Py_BuildValue("l",
26175                          _rv);
26176     return _res;
26177 }
26178
26179 static PyObject *Qt_TuneSetPartMix(PyObject *_self, PyObject *_args)
26180 {
26181     PyObject *_res = NULL;
26182     ComponentResult _rv;
26183     TunePlayer tp;
26184     unsigned long partNumber;
26185     long volume;
26186     long balance;
26187     long mixFlags;
26188 #ifndef TuneSetPartMix
26189     PyMac_PRECHECK(TuneSetPartMix);
26190 #endif
26191     if (!PyArg_ParseTuple(_args, "O&llll",
26192                           CmpInstObj_Convert, &tp,
26193                           &partNumber,
26194                           &volume,
26195                           &balance,
26196                           &mixFlags))
26197         return NULL;
26198     _rv = TuneSetPartMix(tp,
26199                          partNumber,
26200                          volume,
26201                          balance,
26202                          mixFlags);
26203     _res = Py_BuildValue("l",
26204                          _rv);
26205     return _res;
26206 }
26207
26208 static PyObject *Qt_TuneGetPartMix(PyObject *_self, PyObject *_args)
26209 {
26210     PyObject *_res = NULL;
26211     ComponentResult _rv;
26212     TunePlayer tp;
26213     unsigned long partNumber;
26214     long volumeOut;
26215     long balanceOut;
26216     long mixFlagsOut;
26217 #ifndef TuneGetPartMix
26218     PyMac_PRECHECK(TuneGetPartMix);
26219 #endif
26220     if (!PyArg_ParseTuple(_args, "O&l",
26221                           CmpInstObj_Convert, &tp,
26222                           &partNumber))
26223         return NULL;
26224     _rv = TuneGetPartMix(tp,
26225                          partNumber,
26226                          &volumeOut,
26227                          &balanceOut,
26228                          &mixFlagsOut);
26229     _res = Py_BuildValue("llll",
26230                          _rv,
26231                          volumeOut,
26232                          balanceOut,
26233                          mixFlagsOut);
26234     return _res;
26235 }
26236
26237 static PyObject *Qt_AlignWindow(PyObject *_self, PyObject *_args)
26238 {
26239     PyObject *_res = NULL;
26240     WindowPtr wp;
26241     Boolean front;
26242 #ifndef AlignWindow
26243     PyMac_PRECHECK(AlignWindow);
26244 #endif
26245     if (!PyArg_ParseTuple(_args, "O&b",
26246                           WinObj_Convert, &wp,
26247                           &front))
26248         return NULL;
26249     AlignWindow(wp,
26250                 front,
26251                 (Rect *)0,
26252                 (ICMAlignmentProcRecordPtr)0);
26253     Py_INCREF(Py_None);
26254     _res = Py_None;
26255     return _res;
26256 }
26257
26258 static PyObject *Qt_DragAlignedWindow(PyObject *_self, PyObject *_args)
26259 {
26260     PyObject *_res = NULL;
26261     WindowPtr wp;
26262     Point startPt;
26263     Rect boundsRect;
26264 #ifndef DragAlignedWindow
26265     PyMac_PRECHECK(DragAlignedWindow);
26266 #endif
26267     if (!PyArg_ParseTuple(_args, "O&O&O&",
26268                           WinObj_Convert, &wp,
26269                           PyMac_GetPoint, &startPt,
26270                           PyMac_GetRect, &boundsRect))
26271         return NULL;
26272     DragAlignedWindow(wp,
26273                       startPt,
26274                       &boundsRect,
26275                       (Rect *)0,
26276                       (ICMAlignmentProcRecordPtr)0);
26277     Py_INCREF(Py_None);
26278     _res = Py_None;
26279     return _res;
26280 }
26281
26282 static PyObject *Qt_MoviesTask(PyObject *_self, PyObject *_args)
26283 {
26284     PyObject *_res = NULL;
26285     long maxMilliSecToUse;
26286 #ifndef MoviesTask
26287     PyMac_PRECHECK(MoviesTask);
26288 #endif
26289     if (!PyArg_ParseTuple(_args, "l",
26290                           &maxMilliSecToUse))
26291         return NULL;
26292     MoviesTask((Movie)0,
26293                maxMilliSecToUse);
26294     Py_INCREF(Py_None);
26295     _res = Py_None;
26296     return _res;
26297 }
26298 #endif /* __LP64__ */
26299
26300 static PyMethodDef Qt_methods[] = {
26301 #ifndef __LP64__
26302     {"EnterMovies", (PyCFunction)Qt_EnterMovies, 1,
26303      PyDoc_STR("() -> None")},
26304     {"ExitMovies", (PyCFunction)Qt_ExitMovies, 1,
26305      PyDoc_STR("() -> None")},
26306     {"GetMoviesError", (PyCFunction)Qt_GetMoviesError, 1,
26307      PyDoc_STR("() -> None")},
26308     {"ClearMoviesStickyError", (PyCFunction)Qt_ClearMoviesStickyError, 1,
26309      PyDoc_STR("() -> None")},
26310     {"GetMoviesStickyError", (PyCFunction)Qt_GetMoviesStickyError, 1,
26311      PyDoc_STR("() -> None")},
26312     {"QTGetWallClockTimeBase", (PyCFunction)Qt_QTGetWallClockTimeBase, 1,
26313      PyDoc_STR("() -> (TimeBase wallClockTimeBase)")},
26314     {"QTIdleManagerOpen", (PyCFunction)Qt_QTIdleManagerOpen, 1,
26315      PyDoc_STR("() -> (IdleManager _rv)")},
26316     {"CreateMovieControl", (PyCFunction)Qt_CreateMovieControl, 1,
26317      PyDoc_STR("(WindowPtr theWindow, Movie theMovie, UInt32 options) -> (Rect localRect, ControlHandle returnedControl)")},
26318     {"DisposeMatte", (PyCFunction)Qt_DisposeMatte, 1,
26319      PyDoc_STR("(PixMapHandle theMatte) -> None")},
26320     {"NewMovie", (PyCFunction)Qt_NewMovie, 1,
26321      PyDoc_STR("(long flags) -> (Movie _rv)")},
26322     {"QTGetTimeUntilNextTask", (PyCFunction)Qt_QTGetTimeUntilNextTask, 1,
26323      PyDoc_STR("(long scale) -> (long duration)")},
26324     {"GetDataHandler", (PyCFunction)Qt_GetDataHandler, 1,
26325      PyDoc_STR("(Handle dataRef, OSType dataHandlerSubType, long flags) -> (Component _rv)")},
26326     {"PasteHandleIntoMovie", (PyCFunction)Qt_PasteHandleIntoMovie, 1,
26327      PyDoc_STR("(Handle h, OSType handleType, Movie theMovie, long flags, ComponentInstance userComp) -> None")},
26328     {"GetMovieImporterForDataRef", (PyCFunction)Qt_GetMovieImporterForDataRef, 1,
26329      PyDoc_STR("(OSType dataRefType, Handle dataRef, long flags) -> (Component importer)")},
26330     {"QTGetMIMETypeInfo", (PyCFunction)Qt_QTGetMIMETypeInfo, 1,
26331      PyDoc_STR("(char* mimeStringStart, short mimeStringLength, OSType infoSelector, void * infoDataPtr) -> (long infoDataSize)")},
26332     {"TrackTimeToMediaTime", (PyCFunction)Qt_TrackTimeToMediaTime, 1,
26333      PyDoc_STR("(TimeValue value, Track theTrack) -> (TimeValue _rv)")},
26334     {"NewUserData", (PyCFunction)Qt_NewUserData, 1,
26335      PyDoc_STR("() -> (UserData theUserData)")},
26336     {"NewUserDataFromHandle", (PyCFunction)Qt_NewUserDataFromHandle, 1,
26337      PyDoc_STR("(Handle h) -> (UserData theUserData)")},
26338     {"CreateMovieFile", (PyCFunction)Qt_CreateMovieFile, 1,
26339      PyDoc_STR("(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (short resRefNum, Movie newmovie)")},
26340     {"OpenMovieFile", (PyCFunction)Qt_OpenMovieFile, 1,
26341      PyDoc_STR("(FSSpec fileSpec, SInt8 permission) -> (short resRefNum)")},
26342     {"CloseMovieFile", (PyCFunction)Qt_CloseMovieFile, 1,
26343      PyDoc_STR("(short resRefNum) -> None")},
26344     {"DeleteMovieFile", (PyCFunction)Qt_DeleteMovieFile, 1,
26345      PyDoc_STR("(FSSpec fileSpec) -> None")},
26346     {"NewMovieFromFile", (PyCFunction)Qt_NewMovieFromFile, 1,
26347      PyDoc_STR("(short resRefNum, short resId, short newMovieFlags) -> (Movie theMovie, short resId, Boolean dataRefWasChanged)")},
26348     {"NewMovieFromHandle", (PyCFunction)Qt_NewMovieFromHandle, 1,
26349      PyDoc_STR("(Handle h, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)")},
26350     {"NewMovieFromDataFork", (PyCFunction)Qt_NewMovieFromDataFork, 1,
26351      PyDoc_STR("(short fRefNum, long fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)")},
26352     {"NewMovieFromDataFork64", (PyCFunction)Qt_NewMovieFromDataFork64, 1,
26353      PyDoc_STR("(long fRefNum, wide fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)")},
26354     {"NewMovieFromDataRef", (PyCFunction)Qt_NewMovieFromDataRef, 1,
26355      PyDoc_STR("(short flags, Handle dataRef, OSType dtaRefType) -> (Movie m, short id)")},
26356     {"NewMovieFromStorageOffset", (PyCFunction)Qt_NewMovieFromStorageOffset, 1,
26357      PyDoc_STR("(DataHandler dh, wide fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasCataRefType)")},
26358     {"NewMovieForDataRefFromHandle", (PyCFunction)Qt_NewMovieForDataRefFromHandle, 1,
26359      PyDoc_STR("(Handle h, short newMovieFlags, Handle dataRef, OSType dataRefType) -> (Movie theMovie, Boolean dataRefWasChanged)")},
26360     {"RemoveMovieResource", (PyCFunction)Qt_RemoveMovieResource, 1,
26361      PyDoc_STR("(short resRefNum, short resId) -> None")},
26362     {"CreateMovieStorage", (PyCFunction)Qt_CreateMovieStorage, 1,
26363      PyDoc_STR("(Handle dataRef, OSType dataRefType, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (DataHandler outDataHandler, Movie newmovie)")},
26364     {"OpenMovieStorage", (PyCFunction)Qt_OpenMovieStorage, 1,
26365      PyDoc_STR("(Handle dataRef, OSType dataRefType, long flags) -> (DataHandler outDataHandler)")},
26366     {"CloseMovieStorage", (PyCFunction)Qt_CloseMovieStorage, 1,
26367      PyDoc_STR("(DataHandler dh) -> None")},
26368     {"DeleteMovieStorage", (PyCFunction)Qt_DeleteMovieStorage, 1,
26369      PyDoc_STR("(Handle dataRef, OSType dataRefType) -> None")},
26370     {"CreateShortcutMovieFile", (PyCFunction)Qt_CreateShortcutMovieFile, 1,
26371      PyDoc_STR("(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Handle targetDataRef, OSType targetDataRefType) -> None")},
26372     {"CanQuickTimeOpenFile", (PyCFunction)Qt_CanQuickTimeOpenFile, 1,
26373      PyDoc_STR("(FSSpec fileSpec, OSType fileType, OSType fileNameExtension, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)")},
26374     {"CanQuickTimeOpenDataRef", (PyCFunction)Qt_CanQuickTimeOpenDataRef, 1,
26375      PyDoc_STR("(Handle dataRef, OSType dataRefType, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)")},
26376     {"NewMovieFromScrap", (PyCFunction)Qt_NewMovieFromScrap, 1,
26377      PyDoc_STR("(long newMovieFlags) -> (Movie _rv)")},
26378     {"QTNewAlias", (PyCFunction)Qt_QTNewAlias, 1,
26379      PyDoc_STR("(FSSpec fss, Boolean minimal) -> (AliasHandle alias)")},
26380     {"EndFullScreen", (PyCFunction)Qt_EndFullScreen, 1,
26381      PyDoc_STR("(Ptr fullState, long flags) -> None")},
26382     {"AddSoundDescriptionExtension", (PyCFunction)Qt_AddSoundDescriptionExtension, 1,
26383      PyDoc_STR("(SoundDescriptionHandle desc, Handle extension, OSType idType) -> None")},
26384     {"GetSoundDescriptionExtension", (PyCFunction)Qt_GetSoundDescriptionExtension, 1,
26385      PyDoc_STR("(SoundDescriptionHandle desc, OSType idType) -> (Handle extension)")},
26386     {"RemoveSoundDescriptionExtension", (PyCFunction)Qt_RemoveSoundDescriptionExtension, 1,
26387      PyDoc_STR("(SoundDescriptionHandle desc, OSType idType) -> None")},
26388     {"QTIsStandardParameterDialogEvent", (PyCFunction)Qt_QTIsStandardParameterDialogEvent, 1,
26389      PyDoc_STR("(QTParameterDialog createdDialog) -> (EventRecord pEvent)")},
26390     {"QTDismissStandardParameterDialog", (PyCFunction)Qt_QTDismissStandardParameterDialog, 1,
26391      PyDoc_STR("(QTParameterDialog createdDialog) -> None")},
26392     {"QTStandardParameterDialogDoAction", (PyCFunction)Qt_QTStandardParameterDialogDoAction, 1,
26393      PyDoc_STR("(QTParameterDialog createdDialog, long action, void * params) -> None")},
26394     {"QTRegisterAccessKey", (PyCFunction)Qt_QTRegisterAccessKey, 1,
26395      PyDoc_STR("(Str255 accessKeyType, long flags, Handle accessKey) -> None")},
26396     {"QTUnregisterAccessKey", (PyCFunction)Qt_QTUnregisterAccessKey, 1,
26397      PyDoc_STR("(Str255 accessKeyType, long flags, Handle accessKey) -> None")},
26398     {"QTGetSupportedRestrictions", (PyCFunction)Qt_QTGetSupportedRestrictions, 1,
26399      PyDoc_STR("(OSType inRestrictionClass) -> (UInt32 outRestrictionIDs)")},
26400     {"QTTextToNativeText", (PyCFunction)Qt_QTTextToNativeText, 1,
26401      PyDoc_STR("(Handle theText, long encoding, long flags) -> None")},
26402     {"VideoMediaResetStatistics", (PyCFunction)Qt_VideoMediaResetStatistics, 1,
26403      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
26404     {"VideoMediaGetStatistics", (PyCFunction)Qt_VideoMediaGetStatistics, 1,
26405      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
26406     {"VideoMediaGetStallCount", (PyCFunction)Qt_VideoMediaGetStallCount, 1,
26407      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, unsigned long stalls)")},
26408     {"VideoMediaSetCodecParameter", (PyCFunction)Qt_VideoMediaSetCodecParameter, 1,
26409      PyDoc_STR("(MediaHandler mh, CodecType cType, OSType parameterID, long parameterChangeSeed, void * dataPtr, long dataSize) -> (ComponentResult _rv)")},
26410     {"VideoMediaGetCodecParameter", (PyCFunction)Qt_VideoMediaGetCodecParameter, 1,
26411      PyDoc_STR("(MediaHandler mh, CodecType cType, OSType parameterID, Handle outParameterData) -> (ComponentResult _rv)")},
26412     {"TextMediaAddTextSample", (PyCFunction)Qt_TextMediaAddTextSample, 1,
26413      PyDoc_STR("(MediaHandler mh, Ptr text, unsigned long size, short fontNumber, short fontSize, Style textFace, short textJustification, long displayFlags, TimeValue scrollDelay, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor textColor, RGBColor backColor, Rect textBox, RGBColor rgbHiliteColor, TimeValue sampleTime)")},
26414     {"TextMediaAddTESample", (PyCFunction)Qt_TextMediaAddTESample, 1,
26415      PyDoc_STR("(MediaHandler mh, TEHandle hTE, short textJustification, long displayFlags, TimeValue scrollDelay, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor backColor, Rect textBox, RGBColor rgbHiliteColor, TimeValue sampleTime)")},
26416     {"TextMediaAddHiliteSample", (PyCFunction)Qt_TextMediaAddHiliteSample, 1,
26417      PyDoc_STR("(MediaHandler mh, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor rgbHiliteColor, TimeValue sampleTime)")},
26418     {"TextMediaDrawRaw", (PyCFunction)Qt_TextMediaDrawRaw, 1,
26419      PyDoc_STR("(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh) -> (ComponentResult _rv)")},
26420     {"TextMediaSetTextProperty", (PyCFunction)Qt_TextMediaSetTextProperty, 1,
26421      PyDoc_STR("(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)")},
26422     {"TextMediaRawSetup", (PyCFunction)Qt_TextMediaRawSetup, 1,
26423      PyDoc_STR("(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh, TimeValue sampleDuration) -> (ComponentResult _rv)")},
26424     {"TextMediaRawIdle", (PyCFunction)Qt_TextMediaRawIdle, 1,
26425      PyDoc_STR("(MediaHandler mh, GWorldPtr gw, GDHandle gd, TimeValue sampleTime, long flagsIn) -> (ComponentResult _rv, long flagsOut)")},
26426     {"TextMediaGetTextProperty", (PyCFunction)Qt_TextMediaGetTextProperty, 1,
26427      PyDoc_STR("(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)")},
26428     {"TextMediaFindNextText", (PyCFunction)Qt_TextMediaFindNextText, 1,
26429      PyDoc_STR("(MediaHandler mh, Ptr text, long size, short findFlags, TimeValue startTime) -> (ComponentResult _rv, TimeValue foundTime, TimeValue foundDuration, long offset)")},
26430     {"TextMediaHiliteTextSample", (PyCFunction)Qt_TextMediaHiliteTextSample, 1,
26431      PyDoc_STR("(MediaHandler mh, TimeValue sampleTime, short hiliteStart, short hiliteEnd) -> (ComponentResult _rv, RGBColor rgbHiliteColor)")},
26432     {"TextMediaSetTextSampleData", (PyCFunction)Qt_TextMediaSetTextSampleData, 1,
26433      PyDoc_STR("(MediaHandler mh, void * data, OSType dataType) -> (ComponentResult _rv)")},
26434     {"SpriteMediaSetProperty", (PyCFunction)Qt_SpriteMediaSetProperty, 1,
26435      PyDoc_STR("(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
26436     {"SpriteMediaGetProperty", (PyCFunction)Qt_SpriteMediaGetProperty, 1,
26437      PyDoc_STR("(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
26438     {"SpriteMediaHitTestSprites", (PyCFunction)Qt_SpriteMediaHitTestSprites, 1,
26439      PyDoc_STR("(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, short spriteHitIndex)")},
26440     {"SpriteMediaCountSprites", (PyCFunction)Qt_SpriteMediaCountSprites, 1,
26441      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, short numSprites)")},
26442     {"SpriteMediaCountImages", (PyCFunction)Qt_SpriteMediaCountImages, 1,
26443      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, short numImages)")},
26444     {"SpriteMediaGetIndImageDescription", (PyCFunction)Qt_SpriteMediaGetIndImageDescription, 1,
26445      PyDoc_STR("(MediaHandler mh, short imageIndex, ImageDescriptionHandle imageDescription) -> (ComponentResult _rv)")},
26446     {"SpriteMediaGetDisplayedSampleNumber", (PyCFunction)Qt_SpriteMediaGetDisplayedSampleNumber, 1,
26447      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, long sampleNum)")},
26448     {"SpriteMediaGetSpriteName", (PyCFunction)Qt_SpriteMediaGetSpriteName, 1,
26449      PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, Str255 spriteName) -> (ComponentResult _rv)")},
26450     {"SpriteMediaGetImageName", (PyCFunction)Qt_SpriteMediaGetImageName, 1,
26451      PyDoc_STR("(MediaHandler mh, short imageIndex, Str255 imageName) -> (ComponentResult _rv)")},
26452     {"SpriteMediaSetSpriteProperty", (PyCFunction)Qt_SpriteMediaSetSpriteProperty, 1,
26453      PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
26454     {"SpriteMediaGetSpriteProperty", (PyCFunction)Qt_SpriteMediaGetSpriteProperty, 1,
26455      PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
26456     {"SpriteMediaHitTestAllSprites", (PyCFunction)Qt_SpriteMediaHitTestAllSprites, 1,
26457      PyDoc_STR("(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, QTAtomID spriteHitID)")},
26458     {"SpriteMediaHitTestOneSprite", (PyCFunction)Qt_SpriteMediaHitTestOneSprite, 1,
26459      PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, long flags, Point loc) -> (ComponentResult _rv, Boolean wasHit)")},
26460     {"SpriteMediaSpriteIndexToID", (PyCFunction)Qt_SpriteMediaSpriteIndexToID, 1,
26461      PyDoc_STR("(MediaHandler mh, short spriteIndex) -> (ComponentResult _rv, QTAtomID spriteID)")},
26462     {"SpriteMediaSpriteIDToIndex", (PyCFunction)Qt_SpriteMediaSpriteIDToIndex, 1,
26463      PyDoc_STR("(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv, short spriteIndex)")},
26464     {"SpriteMediaSetActionVariable", (PyCFunction)Qt_SpriteMediaSetActionVariable, 1,
26465      PyDoc_STR("(MediaHandler mh, QTAtomID variableID, float value) -> (ComponentResult _rv)")},
26466     {"SpriteMediaGetActionVariable", (PyCFunction)Qt_SpriteMediaGetActionVariable, 1,
26467      PyDoc_STR("(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, float value)")},
26468     {"SpriteMediaDisposeSprite", (PyCFunction)Qt_SpriteMediaDisposeSprite, 1,
26469      PyDoc_STR("(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv)")},
26470     {"SpriteMediaSetActionVariableToString", (PyCFunction)Qt_SpriteMediaSetActionVariableToString, 1,
26471      PyDoc_STR("(MediaHandler mh, QTAtomID variableID, Ptr theCString) -> (ComponentResult _rv)")},
26472     {"SpriteMediaGetActionVariableAsString", (PyCFunction)Qt_SpriteMediaGetActionVariableAsString, 1,
26473      PyDoc_STR("(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, Handle theCString)")},
26474     {"SpriteMediaNewImage", (PyCFunction)Qt_SpriteMediaNewImage, 1,
26475      PyDoc_STR("(MediaHandler mh, Handle dataRef, OSType dataRefType, QTAtomID desiredID) -> (ComponentResult _rv)")},
26476     {"SpriteMediaDisposeImage", (PyCFunction)Qt_SpriteMediaDisposeImage, 1,
26477      PyDoc_STR("(MediaHandler mh, short imageIndex) -> (ComponentResult _rv)")},
26478     {"SpriteMediaImageIndexToID", (PyCFunction)Qt_SpriteMediaImageIndexToID, 1,
26479      PyDoc_STR("(MediaHandler mh, short imageIndex) -> (ComponentResult _rv, QTAtomID imageID)")},
26480     {"SpriteMediaImageIDToIndex", (PyCFunction)Qt_SpriteMediaImageIDToIndex, 1,
26481      PyDoc_STR("(MediaHandler mh, QTAtomID imageID) -> (ComponentResult _rv, short imageIndex)")},
26482     {"FlashMediaSetPan", (PyCFunction)Qt_FlashMediaSetPan, 1,
26483      PyDoc_STR("(MediaHandler mh, short xPercent, short yPercent) -> (ComponentResult _rv)")},
26484     {"FlashMediaSetZoom", (PyCFunction)Qt_FlashMediaSetZoom, 1,
26485      PyDoc_STR("(MediaHandler mh, short factor) -> (ComponentResult _rv)")},
26486     {"FlashMediaSetZoomRect", (PyCFunction)Qt_FlashMediaSetZoomRect, 1,
26487      PyDoc_STR("(MediaHandler mh, long left, long top, long right, long bottom) -> (ComponentResult _rv)")},
26488     {"FlashMediaGetRefConBounds", (PyCFunction)Qt_FlashMediaGetRefConBounds, 1,
26489      PyDoc_STR("(MediaHandler mh, long refCon) -> (ComponentResult _rv, long left, long top, long right, long bottom)")},
26490     {"FlashMediaGetRefConID", (PyCFunction)Qt_FlashMediaGetRefConID, 1,
26491      PyDoc_STR("(MediaHandler mh, long refCon) -> (ComponentResult _rv, long refConID)")},
26492     {"FlashMediaIDToRefCon", (PyCFunction)Qt_FlashMediaIDToRefCon, 1,
26493      PyDoc_STR("(MediaHandler mh, long refConID) -> (ComponentResult _rv, long refCon)")},
26494     {"FlashMediaGetDisplayedFrameNumber", (PyCFunction)Qt_FlashMediaGetDisplayedFrameNumber, 1,
26495      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, long flashFrameNumber)")},
26496     {"FlashMediaFrameNumberToMovieTime", (PyCFunction)Qt_FlashMediaFrameNumberToMovieTime, 1,
26497      PyDoc_STR("(MediaHandler mh, long flashFrameNumber) -> (ComponentResult _rv, TimeValue movieTime)")},
26498     {"FlashMediaFrameLabelToMovieTime", (PyCFunction)Qt_FlashMediaFrameLabelToMovieTime, 1,
26499      PyDoc_STR("(MediaHandler mh, Ptr theLabel) -> (ComponentResult _rv, TimeValue movieTime)")},
26500     {"FlashMediaGetFlashVariable", (PyCFunction)Qt_FlashMediaGetFlashVariable, 1,
26501      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, char path, char name, Handle theVariableCStringOut)")},
26502     {"FlashMediaSetFlashVariable", (PyCFunction)Qt_FlashMediaSetFlashVariable, 1,
26503      PyDoc_STR("(MediaHandler mh, Boolean updateFocus) -> (ComponentResult _rv, char path, char name, char value)")},
26504     {"FlashMediaDoButtonActions", (PyCFunction)Qt_FlashMediaDoButtonActions, 1,
26505      PyDoc_STR("(MediaHandler mh, long buttonID, long transition) -> (ComponentResult _rv, char path)")},
26506     {"FlashMediaGetSupportedSwfVersion", (PyCFunction)Qt_FlashMediaGetSupportedSwfVersion, 1,
26507      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, UInt8 swfVersion)")},
26508     {"Media3DGetCurrentGroup", (PyCFunction)Qt_Media3DGetCurrentGroup, 1,
26509      PyDoc_STR("(MediaHandler mh, void * group) -> (ComponentResult _rv)")},
26510     {"Media3DTranslateNamedObjectTo", (PyCFunction)Qt_Media3DTranslateNamedObjectTo, 1,
26511      PyDoc_STR("(MediaHandler mh, Fixed x, Fixed y, Fixed z) -> (ComponentResult _rv, char objectName)")},
26512     {"Media3DScaleNamedObjectTo", (PyCFunction)Qt_Media3DScaleNamedObjectTo, 1,
26513      PyDoc_STR("(MediaHandler mh, Fixed xScale, Fixed yScale, Fixed zScale) -> (ComponentResult _rv, char objectName)")},
26514     {"Media3DRotateNamedObjectTo", (PyCFunction)Qt_Media3DRotateNamedObjectTo, 1,
26515      PyDoc_STR("(MediaHandler mh, Fixed xDegrees, Fixed yDegrees, Fixed zDegrees) -> (ComponentResult _rv, char objectName)")},
26516     {"Media3DSetCameraData", (PyCFunction)Qt_Media3DSetCameraData, 1,
26517      PyDoc_STR("(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)")},
26518     {"Media3DGetCameraData", (PyCFunction)Qt_Media3DGetCameraData, 1,
26519      PyDoc_STR("(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)")},
26520     {"Media3DSetCameraAngleAspect", (PyCFunction)Qt_Media3DSetCameraAngleAspect, 1,
26521      PyDoc_STR("(MediaHandler mh, QTFloatSingle fov, QTFloatSingle aspectRatioXToY) -> (ComponentResult _rv)")},
26522     {"Media3DGetCameraAngleAspect", (PyCFunction)Qt_Media3DGetCameraAngleAspect, 1,
26523      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, QTFloatSingle fov, QTFloatSingle aspectRatioXToY)")},
26524     {"Media3DSetCameraRange", (PyCFunction)Qt_Media3DSetCameraRange, 1,
26525      PyDoc_STR("(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)")},
26526     {"Media3DGetCameraRange", (PyCFunction)Qt_Media3DGetCameraRange, 1,
26527      PyDoc_STR("(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)")},
26528     {"NewTimeBase", (PyCFunction)Qt_NewTimeBase, 1,
26529      PyDoc_STR("() -> (TimeBase _rv)")},
26530     {"ConvertTime", (PyCFunction)Qt_ConvertTime, 1,
26531      PyDoc_STR("(TimeRecord theTime, TimeBase newBase) -> (TimeRecord theTime)")},
26532     {"ConvertTimeScale", (PyCFunction)Qt_ConvertTimeScale, 1,
26533      PyDoc_STR("(TimeRecord theTime, TimeScale newScale) -> (TimeRecord theTime)")},
26534     {"AddTime", (PyCFunction)Qt_AddTime, 1,
26535      PyDoc_STR("(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)")},
26536     {"SubtractTime", (PyCFunction)Qt_SubtractTime, 1,
26537      PyDoc_STR("(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)")},
26538     {"MusicMediaGetIndexedTunePlayer", (PyCFunction)Qt_MusicMediaGetIndexedTunePlayer, 1,
26539      PyDoc_STR("(ComponentInstance ti, long sampleDescIndex) -> (ComponentResult _rv, ComponentInstance tp)")},
26540     {"CodecManagerVersion", (PyCFunction)Qt_CodecManagerVersion, 1,
26541      PyDoc_STR("() -> (long version)")},
26542     {"GetMaxCompressionSize", (PyCFunction)Qt_GetMaxCompressionSize, 1,
26543      PyDoc_STR("(PixMapHandle src, Rect srcRect, short colorDepth, CodecQ quality, CodecType cType, CompressorComponent codec) -> (long size)")},
26544     {"GetCompressionTime", (PyCFunction)Qt_GetCompressionTime, 1,
26545      PyDoc_STR("(PixMapHandle src, Rect srcRect, short colorDepth, CodecType cType, CompressorComponent codec) -> (CodecQ spatialQuality, CodecQ temporalQuality, unsigned long compressTime)")},
26546     {"CompressImage", (PyCFunction)Qt_CompressImage, 1,
26547      PyDoc_STR("(PixMapHandle src, Rect srcRect, CodecQ quality, CodecType cType, ImageDescriptionHandle desc, Ptr data) -> None")},
26548     {"DecompressImage", (PyCFunction)Qt_DecompressImage, 1,
26549      PyDoc_STR("(Ptr data, ImageDescriptionHandle desc, PixMapHandle dst, Rect srcRect, Rect dstRect, short mode, RgnHandle mask) -> None")},
26550     {"GetSimilarity", (PyCFunction)Qt_GetSimilarity, 1,
26551      PyDoc_STR("(PixMapHandle src, Rect srcRect, ImageDescriptionHandle desc, Ptr data) -> (Fixed similarity)")},
26552     {"GetImageDescriptionCTable", (PyCFunction)Qt_GetImageDescriptionCTable, 1,
26553      PyDoc_STR("(ImageDescriptionHandle desc) -> (CTabHandle ctable)")},
26554     {"SetImageDescriptionCTable", (PyCFunction)Qt_SetImageDescriptionCTable, 1,
26555      PyDoc_STR("(ImageDescriptionHandle desc, CTabHandle ctable) -> None")},
26556     {"GetImageDescriptionExtension", (PyCFunction)Qt_GetImageDescriptionExtension, 1,
26557      PyDoc_STR("(ImageDescriptionHandle desc, long idType, long index) -> (Handle extension)")},
26558     {"AddImageDescriptionExtension", (PyCFunction)Qt_AddImageDescriptionExtension, 1,
26559      PyDoc_STR("(ImageDescriptionHandle desc, Handle extension, long idType) -> None")},
26560     {"RemoveImageDescriptionExtension", (PyCFunction)Qt_RemoveImageDescriptionExtension, 1,
26561      PyDoc_STR("(ImageDescriptionHandle desc, long idType, long index) -> None")},
26562     {"CountImageDescriptionExtensionType", (PyCFunction)Qt_CountImageDescriptionExtensionType, 1,
26563      PyDoc_STR("(ImageDescriptionHandle desc, long idType) -> (long count)")},
26564     {"GetNextImageDescriptionExtensionType", (PyCFunction)Qt_GetNextImageDescriptionExtensionType, 1,
26565      PyDoc_STR("(ImageDescriptionHandle desc) -> (long idType)")},
26566     {"FindCodec", (PyCFunction)Qt_FindCodec, 1,
26567      PyDoc_STR("(CodecType cType, CodecComponent specCodec) -> (CompressorComponent compressor, DecompressorComponent decompressor)")},
26568     {"CompressPicture", (PyCFunction)Qt_CompressPicture, 1,
26569      PyDoc_STR("(PicHandle srcPicture, PicHandle dstPicture, CodecQ quality, CodecType cType) -> None")},
26570     {"CompressPictureFile", (PyCFunction)Qt_CompressPictureFile, 1,
26571      PyDoc_STR("(short srcRefNum, short dstRefNum, CodecQ quality, CodecType cType) -> None")},
26572     {"ConvertImage", (PyCFunction)Qt_ConvertImage, 1,
26573      PyDoc_STR("(ImageDescriptionHandle srcDD, Ptr srcData, short colorDepth, CTabHandle ctable, CodecQ accuracy, CodecQ quality, CodecType cType, CodecComponent codec, ImageDescriptionHandle dstDD, Ptr dstData) -> None")},
26574     {"AddFilePreview", (PyCFunction)Qt_AddFilePreview, 1,
26575      PyDoc_STR("(short resRefNum, OSType previewType, Handle previewData) -> None")},
26576     {"GetBestDeviceRect", (PyCFunction)Qt_GetBestDeviceRect, 1,
26577      PyDoc_STR("() -> (GDHandle gdh, Rect rp)")},
26578     {"GDHasScale", (PyCFunction)Qt_GDHasScale, 1,
26579      PyDoc_STR("(GDHandle gdh, short depth) -> (Fixed scale)")},
26580     {"GDGetScale", (PyCFunction)Qt_GDGetScale, 1,
26581      PyDoc_STR("(GDHandle gdh) -> (Fixed scale, short flags)")},
26582     {"GDSetScale", (PyCFunction)Qt_GDSetScale, 1,
26583      PyDoc_STR("(GDHandle gdh, Fixed scale, short flags) -> None")},
26584     {"GetGraphicsImporterForFile", (PyCFunction)Qt_GetGraphicsImporterForFile, 1,
26585      PyDoc_STR("(FSSpec theFile) -> (ComponentInstance gi)")},
26586     {"GetGraphicsImporterForDataRef", (PyCFunction)Qt_GetGraphicsImporterForDataRef, 1,
26587      PyDoc_STR("(Handle dataRef, OSType dataRefType) -> (ComponentInstance gi)")},
26588     {"GetGraphicsImporterForFileWithFlags", (PyCFunction)Qt_GetGraphicsImporterForFileWithFlags, 1,
26589      PyDoc_STR("(FSSpec theFile, long flags) -> (ComponentInstance gi)")},
26590     {"GetGraphicsImporterForDataRefWithFlags", (PyCFunction)Qt_GetGraphicsImporterForDataRefWithFlags, 1,
26591      PyDoc_STR("(Handle dataRef, OSType dataRefType, long flags) -> (ComponentInstance gi)")},
26592     {"MakeImageDescriptionForPixMap", (PyCFunction)Qt_MakeImageDescriptionForPixMap, 1,
26593      PyDoc_STR("(PixMapHandle pixmap) -> (ImageDescriptionHandle idh)")},
26594     {"MakeImageDescriptionForEffect", (PyCFunction)Qt_MakeImageDescriptionForEffect, 1,
26595      PyDoc_STR("(OSType effectType) -> (ImageDescriptionHandle idh)")},
26596     {"QTGetPixelSize", (PyCFunction)Qt_QTGetPixelSize, 1,
26597      PyDoc_STR("(OSType PixelFormat) -> (short _rv)")},
26598     {"QTGetPixelFormatDepthForImageDescription", (PyCFunction)Qt_QTGetPixelFormatDepthForImageDescription, 1,
26599      PyDoc_STR("(OSType PixelFormat) -> (short _rv)")},
26600     {"QTGetPixMapHandleRowBytes", (PyCFunction)Qt_QTGetPixMapHandleRowBytes, 1,
26601      PyDoc_STR("(PixMapHandle pm) -> (long _rv)")},
26602     {"QTSetPixMapHandleRowBytes", (PyCFunction)Qt_QTSetPixMapHandleRowBytes, 1,
26603      PyDoc_STR("(PixMapHandle pm, long rowBytes) -> None")},
26604     {"QTGetPixMapHandleGammaLevel", (PyCFunction)Qt_QTGetPixMapHandleGammaLevel, 1,
26605      PyDoc_STR("(PixMapHandle pm) -> (Fixed _rv)")},
26606     {"QTSetPixMapHandleGammaLevel", (PyCFunction)Qt_QTSetPixMapHandleGammaLevel, 1,
26607      PyDoc_STR("(PixMapHandle pm, Fixed gammaLevel) -> None")},
26608     {"QTGetPixMapHandleRequestedGammaLevel", (PyCFunction)Qt_QTGetPixMapHandleRequestedGammaLevel, 1,
26609      PyDoc_STR("(PixMapHandle pm) -> (Fixed _rv)")},
26610     {"QTSetPixMapHandleRequestedGammaLevel", (PyCFunction)Qt_QTSetPixMapHandleRequestedGammaLevel, 1,
26611      PyDoc_STR("(PixMapHandle pm, Fixed requestedGammaLevel) -> None")},
26612     {"CompAdd", (PyCFunction)Qt_CompAdd, 1,
26613      PyDoc_STR("() -> (wide src, wide dst)")},
26614     {"CompSub", (PyCFunction)Qt_CompSub, 1,
26615      PyDoc_STR("() -> (wide src, wide dst)")},
26616     {"CompNeg", (PyCFunction)Qt_CompNeg, 1,
26617      PyDoc_STR("() -> (wide dst)")},
26618     {"CompShift", (PyCFunction)Qt_CompShift, 1,
26619      PyDoc_STR("(short shift) -> (wide src)")},
26620     {"CompMul", (PyCFunction)Qt_CompMul, 1,
26621      PyDoc_STR("(long src1, long src2) -> (wide dst)")},
26622     {"CompDiv", (PyCFunction)Qt_CompDiv, 1,
26623      PyDoc_STR("(long denominator) -> (long _rv, wide numerator, long remainder)")},
26624     {"CompFixMul", (PyCFunction)Qt_CompFixMul, 1,
26625      PyDoc_STR("(Fixed fixSrc) -> (wide compSrc, wide compDst)")},
26626     {"CompMulDiv", (PyCFunction)Qt_CompMulDiv, 1,
26627      PyDoc_STR("(long mul, long divisor) -> (wide co)")},
26628     {"CompMulDivTrunc", (PyCFunction)Qt_CompMulDivTrunc, 1,
26629      PyDoc_STR("(long mul, long divisor) -> (wide co, long remainder)")},
26630     {"CompCompare", (PyCFunction)Qt_CompCompare, 1,
26631      PyDoc_STR("(wide a, wide minusb) -> (long _rv)")},
26632     {"CompSquareRoot", (PyCFunction)Qt_CompSquareRoot, 1,
26633      PyDoc_STR("(wide src) -> (unsigned long _rv)")},
26634     {"FixMulDiv", (PyCFunction)Qt_FixMulDiv, 1,
26635      PyDoc_STR("(Fixed src, Fixed mul, Fixed divisor) -> (Fixed _rv)")},
26636     {"UnsignedFixMulDiv", (PyCFunction)Qt_UnsignedFixMulDiv, 1,
26637      PyDoc_STR("(Fixed src, Fixed mul, Fixed divisor) -> (Fixed _rv)")},
26638     {"FixExp2", (PyCFunction)Qt_FixExp2, 1,
26639      PyDoc_STR("(Fixed src) -> (Fixed _rv)")},
26640     {"FixLog2", (PyCFunction)Qt_FixLog2, 1,
26641      PyDoc_STR("(Fixed src) -> (Fixed _rv)")},
26642     {"FixPow", (PyCFunction)Qt_FixPow, 1,
26643      PyDoc_STR("(Fixed base, Fixed exp) -> (Fixed _rv)")},
26644     {"GraphicsImportSetDataReference", (PyCFunction)Qt_GraphicsImportSetDataReference, 1,
26645      PyDoc_STR("(GraphicsImportComponent ci, Handle dataRef, OSType dataReType) -> (ComponentResult _rv)")},
26646     {"GraphicsImportGetDataReference", (PyCFunction)Qt_GraphicsImportGetDataReference, 1,
26647      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Handle dataRef, OSType dataReType)")},
26648     {"GraphicsImportSetDataFile", (PyCFunction)Qt_GraphicsImportSetDataFile, 1,
26649      PyDoc_STR("(GraphicsImportComponent ci, FSSpec theFile) -> (ComponentResult _rv)")},
26650     {"GraphicsImportGetDataFile", (PyCFunction)Qt_GraphicsImportGetDataFile, 1,
26651      PyDoc_STR("(GraphicsImportComponent ci, FSSpec theFile) -> (ComponentResult _rv)")},
26652     {"GraphicsImportSetDataHandle", (PyCFunction)Qt_GraphicsImportSetDataHandle, 1,
26653      PyDoc_STR("(GraphicsImportComponent ci, Handle h) -> (ComponentResult _rv)")},
26654     {"GraphicsImportGetDataHandle", (PyCFunction)Qt_GraphicsImportGetDataHandle, 1,
26655      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Handle h)")},
26656     {"GraphicsImportGetImageDescription", (PyCFunction)Qt_GraphicsImportGetImageDescription, 1,
26657      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, ImageDescriptionHandle desc)")},
26658     {"GraphicsImportGetDataOffsetAndSize", (PyCFunction)Qt_GraphicsImportGetDataOffsetAndSize, 1,
26659      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, unsigned long offset, unsigned long size)")},
26660     {"GraphicsImportReadData", (PyCFunction)Qt_GraphicsImportReadData, 1,
26661      PyDoc_STR("(GraphicsImportComponent ci, void * dataPtr, unsigned long dataOffset, unsigned long dataSize) -> (ComponentResult _rv)")},
26662     {"GraphicsImportSetClip", (PyCFunction)Qt_GraphicsImportSetClip, 1,
26663      PyDoc_STR("(GraphicsImportComponent ci, RgnHandle clipRgn) -> (ComponentResult _rv)")},
26664     {"GraphicsImportGetClip", (PyCFunction)Qt_GraphicsImportGetClip, 1,
26665      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, RgnHandle clipRgn)")},
26666     {"GraphicsImportSetSourceRect", (PyCFunction)Qt_GraphicsImportSetSourceRect, 1,
26667      PyDoc_STR("(GraphicsImportComponent ci, Rect sourceRect) -> (ComponentResult _rv)")},
26668     {"GraphicsImportGetSourceRect", (PyCFunction)Qt_GraphicsImportGetSourceRect, 1,
26669      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Rect sourceRect)")},
26670     {"GraphicsImportGetNaturalBounds", (PyCFunction)Qt_GraphicsImportGetNaturalBounds, 1,
26671      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Rect naturalBounds)")},
26672     {"GraphicsImportDraw", (PyCFunction)Qt_GraphicsImportDraw, 1,
26673      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv)")},
26674     {"GraphicsImportSetGWorld", (PyCFunction)Qt_GraphicsImportSetGWorld, 1,
26675      PyDoc_STR("(GraphicsImportComponent ci, CGrafPtr port, GDHandle gd) -> (ComponentResult _rv)")},
26676     {"GraphicsImportGetGWorld", (PyCFunction)Qt_GraphicsImportGetGWorld, 1,
26677      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, CGrafPtr port, GDHandle gd)")},
26678     {"GraphicsImportSetBoundsRect", (PyCFunction)Qt_GraphicsImportSetBoundsRect, 1,
26679      PyDoc_STR("(GraphicsImportComponent ci, Rect bounds) -> (ComponentResult _rv)")},
26680     {"GraphicsImportGetBoundsRect", (PyCFunction)Qt_GraphicsImportGetBoundsRect, 1,
26681      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Rect bounds)")},
26682     {"GraphicsImportSaveAsPicture", (PyCFunction)Qt_GraphicsImportSaveAsPicture, 1,
26683      PyDoc_STR("(GraphicsImportComponent ci, FSSpec fss, ScriptCode scriptTag) -> (ComponentResult _rv)")},
26684     {"GraphicsImportSetGraphicsMode", (PyCFunction)Qt_GraphicsImportSetGraphicsMode, 1,
26685      PyDoc_STR("(GraphicsImportComponent ci, long graphicsMode, RGBColor opColor) -> (ComponentResult _rv)")},
26686     {"GraphicsImportGetGraphicsMode", (PyCFunction)Qt_GraphicsImportGetGraphicsMode, 1,
26687      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, long graphicsMode, RGBColor opColor)")},
26688     {"GraphicsImportSetQuality", (PyCFunction)Qt_GraphicsImportSetQuality, 1,
26689      PyDoc_STR("(GraphicsImportComponent ci, CodecQ quality) -> (ComponentResult _rv)")},
26690     {"GraphicsImportGetQuality", (PyCFunction)Qt_GraphicsImportGetQuality, 1,
26691      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, CodecQ quality)")},
26692     {"GraphicsImportSaveAsQuickTimeImageFile", (PyCFunction)Qt_GraphicsImportSaveAsQuickTimeImageFile, 1,
26693      PyDoc_STR("(GraphicsImportComponent ci, FSSpec fss, ScriptCode scriptTag) -> (ComponentResult _rv)")},
26694     {"GraphicsImportSetDataReferenceOffsetAndLimit", (PyCFunction)Qt_GraphicsImportSetDataReferenceOffsetAndLimit, 1,
26695      PyDoc_STR("(GraphicsImportComponent ci, unsigned long offset, unsigned long limit) -> (ComponentResult _rv)")},
26696     {"GraphicsImportGetDataReferenceOffsetAndLimit", (PyCFunction)Qt_GraphicsImportGetDataReferenceOffsetAndLimit, 1,
26697      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, unsigned long offset, unsigned long limit)")},
26698     {"GraphicsImportGetAliasedDataReference", (PyCFunction)Qt_GraphicsImportGetAliasedDataReference, 1,
26699      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Handle dataRef, OSType dataRefType)")},
26700     {"GraphicsImportValidate", (PyCFunction)Qt_GraphicsImportValidate, 1,
26701      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Boolean valid)")},
26702     {"GraphicsImportGetMetaData", (PyCFunction)Qt_GraphicsImportGetMetaData, 1,
26703      PyDoc_STR("(GraphicsImportComponent ci, void * userData) -> (ComponentResult _rv)")},
26704     {"GraphicsImportGetMIMETypeList", (PyCFunction)Qt_GraphicsImportGetMIMETypeList, 1,
26705      PyDoc_STR("(GraphicsImportComponent ci, void * qtAtomContainerPtr) -> (ComponentResult _rv)")},
26706     {"GraphicsImportDoesDrawAllPixels", (PyCFunction)Qt_GraphicsImportDoesDrawAllPixels, 1,
26707      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, short drawsAllPixels)")},
26708     {"GraphicsImportGetAsPicture", (PyCFunction)Qt_GraphicsImportGetAsPicture, 1,
26709      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, PicHandle picture)")},
26710     {"GraphicsImportExportImageFile", (PyCFunction)Qt_GraphicsImportExportImageFile, 1,
26711      PyDoc_STR("(GraphicsImportComponent ci, OSType fileType, OSType fileCreator, FSSpec fss, ScriptCode scriptTag) -> (ComponentResult _rv)")},
26712     {"GraphicsImportGetExportImageTypeList", (PyCFunction)Qt_GraphicsImportGetExportImageTypeList, 1,
26713      PyDoc_STR("(GraphicsImportComponent ci, void * qtAtomContainerPtr) -> (ComponentResult _rv)")},
26714     {"GraphicsImportGetExportSettingsAsAtomContainer", (PyCFunction)Qt_GraphicsImportGetExportSettingsAsAtomContainer, 1,
26715      PyDoc_STR("(GraphicsImportComponent ci, void * qtAtomContainerPtr) -> (ComponentResult _rv)")},
26716     {"GraphicsImportSetExportSettingsFromAtomContainer", (PyCFunction)Qt_GraphicsImportSetExportSettingsFromAtomContainer, 1,
26717      PyDoc_STR("(GraphicsImportComponent ci, void * qtAtomContainer) -> (ComponentResult _rv)")},
26718     {"GraphicsImportGetImageCount", (PyCFunction)Qt_GraphicsImportGetImageCount, 1,
26719      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, unsigned long imageCount)")},
26720     {"GraphicsImportSetImageIndex", (PyCFunction)Qt_GraphicsImportSetImageIndex, 1,
26721      PyDoc_STR("(GraphicsImportComponent ci, unsigned long imageIndex) -> (ComponentResult _rv)")},
26722     {"GraphicsImportGetImageIndex", (PyCFunction)Qt_GraphicsImportGetImageIndex, 1,
26723      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, unsigned long imageIndex)")},
26724     {"GraphicsImportGetDataOffsetAndSize64", (PyCFunction)Qt_GraphicsImportGetDataOffsetAndSize64, 1,
26725      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, wide offset, wide size)")},
26726     {"GraphicsImportReadData64", (PyCFunction)Qt_GraphicsImportReadData64, 1,
26727      PyDoc_STR("(GraphicsImportComponent ci, void * dataPtr, wide dataOffset, unsigned long dataSize) -> (ComponentResult _rv)")},
26728     {"GraphicsImportSetDataReferenceOffsetAndLimit64", (PyCFunction)Qt_GraphicsImportSetDataReferenceOffsetAndLimit64, 1,
26729      PyDoc_STR("(GraphicsImportComponent ci, wide offset, wide limit) -> (ComponentResult _rv)")},
26730     {"GraphicsImportGetDataReferenceOffsetAndLimit64", (PyCFunction)Qt_GraphicsImportGetDataReferenceOffsetAndLimit64, 1,
26731      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, wide offset, wide limit)")},
26732     {"GraphicsImportGetDefaultClip", (PyCFunction)Qt_GraphicsImportGetDefaultClip, 1,
26733      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, RgnHandle defaultRgn)")},
26734     {"GraphicsImportGetDefaultGraphicsMode", (PyCFunction)Qt_GraphicsImportGetDefaultGraphicsMode, 1,
26735      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, long defaultGraphicsMode, RGBColor defaultOpColor)")},
26736     {"GraphicsImportGetDefaultSourceRect", (PyCFunction)Qt_GraphicsImportGetDefaultSourceRect, 1,
26737      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Rect defaultSourceRect)")},
26738     {"GraphicsImportGetColorSyncProfile", (PyCFunction)Qt_GraphicsImportGetColorSyncProfile, 1,
26739      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Handle profile)")},
26740     {"GraphicsImportSetDestRect", (PyCFunction)Qt_GraphicsImportSetDestRect, 1,
26741      PyDoc_STR("(GraphicsImportComponent ci, Rect destRect) -> (ComponentResult _rv)")},
26742     {"GraphicsImportGetDestRect", (PyCFunction)Qt_GraphicsImportGetDestRect, 1,
26743      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, Rect destRect)")},
26744     {"GraphicsImportSetFlags", (PyCFunction)Qt_GraphicsImportSetFlags, 1,
26745      PyDoc_STR("(GraphicsImportComponent ci, long flags) -> (ComponentResult _rv)")},
26746     {"GraphicsImportGetFlags", (PyCFunction)Qt_GraphicsImportGetFlags, 1,
26747      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, long flags)")},
26748     {"GraphicsImportGetBaseDataOffsetAndSize64", (PyCFunction)Qt_GraphicsImportGetBaseDataOffsetAndSize64, 1,
26749      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv, wide offset, wide size)")},
26750     {"GraphicsImportSetImageIndexToThumbnail", (PyCFunction)Qt_GraphicsImportSetImageIndexToThumbnail, 1,
26751      PyDoc_STR("(GraphicsImportComponent ci) -> (ComponentResult _rv)")},
26752     {"GraphicsExportDoExport", (PyCFunction)Qt_GraphicsExportDoExport, 1,
26753      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long actualSizeWritten)")},
26754     {"GraphicsExportCanTranscode", (PyCFunction)Qt_GraphicsExportCanTranscode, 1,
26755      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Boolean canTranscode)")},
26756     {"GraphicsExportDoTranscode", (PyCFunction)Qt_GraphicsExportDoTranscode, 1,
26757      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv)")},
26758     {"GraphicsExportCanUseCompressor", (PyCFunction)Qt_GraphicsExportCanUseCompressor, 1,
26759      PyDoc_STR("(GraphicsExportComponent ci, void * codecSettingsAtomContainerPtr) -> (ComponentResult _rv, Boolean canUseCompressor)")},
26760     {"GraphicsExportDoUseCompressor", (PyCFunction)Qt_GraphicsExportDoUseCompressor, 1,
26761      PyDoc_STR("(GraphicsExportComponent ci, void * codecSettingsAtomContainer) -> (ComponentResult _rv, ImageDescriptionHandle outDesc)")},
26762     {"GraphicsExportDoStandaloneExport", (PyCFunction)Qt_GraphicsExportDoStandaloneExport, 1,
26763      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv)")},
26764     {"GraphicsExportGetDefaultFileTypeAndCreator", (PyCFunction)Qt_GraphicsExportGetDefaultFileTypeAndCreator, 1,
26765      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, OSType fileType, OSType fileCreator)")},
26766     {"GraphicsExportGetDefaultFileNameExtension", (PyCFunction)Qt_GraphicsExportGetDefaultFileNameExtension, 1,
26767      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, OSType fileNameExtension)")},
26768     {"GraphicsExportGetMIMETypeList", (PyCFunction)Qt_GraphicsExportGetMIMETypeList, 1,
26769      PyDoc_STR("(GraphicsExportComponent ci, void * qtAtomContainerPtr) -> (ComponentResult _rv)")},
26770     {"GraphicsExportSetSettingsFromAtomContainer", (PyCFunction)Qt_GraphicsExportSetSettingsFromAtomContainer, 1,
26771      PyDoc_STR("(GraphicsExportComponent ci, void * qtAtomContainer) -> (ComponentResult _rv)")},
26772     {"GraphicsExportGetSettingsAsAtomContainer", (PyCFunction)Qt_GraphicsExportGetSettingsAsAtomContainer, 1,
26773      PyDoc_STR("(GraphicsExportComponent ci, void * qtAtomContainerPtr) -> (ComponentResult _rv)")},
26774     {"GraphicsExportGetSettingsAsText", (PyCFunction)Qt_GraphicsExportGetSettingsAsText, 1,
26775      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Handle theText)")},
26776     {"GraphicsExportSetDontRecompress", (PyCFunction)Qt_GraphicsExportSetDontRecompress, 1,
26777      PyDoc_STR("(GraphicsExportComponent ci, Boolean dontRecompress) -> (ComponentResult _rv)")},
26778     {"GraphicsExportGetDontRecompress", (PyCFunction)Qt_GraphicsExportGetDontRecompress, 1,
26779      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Boolean dontRecompress)")},
26780     {"GraphicsExportSetInterlaceStyle", (PyCFunction)Qt_GraphicsExportSetInterlaceStyle, 1,
26781      PyDoc_STR("(GraphicsExportComponent ci, unsigned long interlaceStyle) -> (ComponentResult _rv)")},
26782     {"GraphicsExportGetInterlaceStyle", (PyCFunction)Qt_GraphicsExportGetInterlaceStyle, 1,
26783      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long interlaceStyle)")},
26784     {"GraphicsExportSetMetaData", (PyCFunction)Qt_GraphicsExportSetMetaData, 1,
26785      PyDoc_STR("(GraphicsExportComponent ci, void * userData) -> (ComponentResult _rv)")},
26786     {"GraphicsExportGetMetaData", (PyCFunction)Qt_GraphicsExportGetMetaData, 1,
26787      PyDoc_STR("(GraphicsExportComponent ci, void * userData) -> (ComponentResult _rv)")},
26788     {"GraphicsExportSetTargetDataSize", (PyCFunction)Qt_GraphicsExportSetTargetDataSize, 1,
26789      PyDoc_STR("(GraphicsExportComponent ci, unsigned long targetDataSize) -> (ComponentResult _rv)")},
26790     {"GraphicsExportGetTargetDataSize", (PyCFunction)Qt_GraphicsExportGetTargetDataSize, 1,
26791      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long targetDataSize)")},
26792     {"GraphicsExportSetCompressionMethod", (PyCFunction)Qt_GraphicsExportSetCompressionMethod, 1,
26793      PyDoc_STR("(GraphicsExportComponent ci, long compressionMethod) -> (ComponentResult _rv)")},
26794     {"GraphicsExportGetCompressionMethod", (PyCFunction)Qt_GraphicsExportGetCompressionMethod, 1,
26795      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, long compressionMethod)")},
26796     {"GraphicsExportSetCompressionQuality", (PyCFunction)Qt_GraphicsExportSetCompressionQuality, 1,
26797      PyDoc_STR("(GraphicsExportComponent ci, CodecQ spatialQuality) -> (ComponentResult _rv)")},
26798     {"GraphicsExportGetCompressionQuality", (PyCFunction)Qt_GraphicsExportGetCompressionQuality, 1,
26799      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, CodecQ spatialQuality)")},
26800     {"GraphicsExportSetResolution", (PyCFunction)Qt_GraphicsExportSetResolution, 1,
26801      PyDoc_STR("(GraphicsExportComponent ci, Fixed horizontalResolution, Fixed verticalResolution) -> (ComponentResult _rv)")},
26802     {"GraphicsExportGetResolution", (PyCFunction)Qt_GraphicsExportGetResolution, 1,
26803      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Fixed horizontalResolution, Fixed verticalResolution)")},
26804     {"GraphicsExportSetDepth", (PyCFunction)Qt_GraphicsExportSetDepth, 1,
26805      PyDoc_STR("(GraphicsExportComponent ci, long depth) -> (ComponentResult _rv)")},
26806     {"GraphicsExportGetDepth", (PyCFunction)Qt_GraphicsExportGetDepth, 1,
26807      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, long depth)")},
26808     {"GraphicsExportSetColorSyncProfile", (PyCFunction)Qt_GraphicsExportSetColorSyncProfile, 1,
26809      PyDoc_STR("(GraphicsExportComponent ci, Handle colorSyncProfile) -> (ComponentResult _rv)")},
26810     {"GraphicsExportGetColorSyncProfile", (PyCFunction)Qt_GraphicsExportGetColorSyncProfile, 1,
26811      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Handle colorSyncProfile)")},
26812     {"GraphicsExportSetInputDataReference", (PyCFunction)Qt_GraphicsExportSetInputDataReference, 1,
26813      PyDoc_STR("(GraphicsExportComponent ci, Handle dataRef, OSType dataRefType, ImageDescriptionHandle desc) -> (ComponentResult _rv)")},
26814     {"GraphicsExportGetInputDataReference", (PyCFunction)Qt_GraphicsExportGetInputDataReference, 1,
26815      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Handle dataRef, OSType dataRefType)")},
26816     {"GraphicsExportSetInputFile", (PyCFunction)Qt_GraphicsExportSetInputFile, 1,
26817      PyDoc_STR("(GraphicsExportComponent ci, FSSpec theFile, ImageDescriptionHandle desc) -> (ComponentResult _rv)")},
26818     {"GraphicsExportGetInputFile", (PyCFunction)Qt_GraphicsExportGetInputFile, 1,
26819      PyDoc_STR("(GraphicsExportComponent ci, FSSpec theFile) -> (ComponentResult _rv)")},
26820     {"GraphicsExportSetInputHandle", (PyCFunction)Qt_GraphicsExportSetInputHandle, 1,
26821      PyDoc_STR("(GraphicsExportComponent ci, Handle h, ImageDescriptionHandle desc) -> (ComponentResult _rv)")},
26822     {"GraphicsExportGetInputHandle", (PyCFunction)Qt_GraphicsExportGetInputHandle, 1,
26823      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Handle h)")},
26824     {"GraphicsExportSetInputPtr", (PyCFunction)Qt_GraphicsExportSetInputPtr, 1,
26825      PyDoc_STR("(GraphicsExportComponent ci, Ptr p, unsigned long size, ImageDescriptionHandle desc) -> (ComponentResult _rv)")},
26826     {"GraphicsExportSetInputGraphicsImporter", (PyCFunction)Qt_GraphicsExportSetInputGraphicsImporter, 1,
26827      PyDoc_STR("(GraphicsExportComponent ci, GraphicsImportComponent grip) -> (ComponentResult _rv)")},
26828     {"GraphicsExportGetInputGraphicsImporter", (PyCFunction)Qt_GraphicsExportGetInputGraphicsImporter, 1,
26829      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, GraphicsImportComponent grip)")},
26830     {"GraphicsExportSetInputPicture", (PyCFunction)Qt_GraphicsExportSetInputPicture, 1,
26831      PyDoc_STR("(GraphicsExportComponent ci, PicHandle picture) -> (ComponentResult _rv)")},
26832     {"GraphicsExportGetInputPicture", (PyCFunction)Qt_GraphicsExportGetInputPicture, 1,
26833      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, PicHandle picture)")},
26834     {"GraphicsExportSetInputGWorld", (PyCFunction)Qt_GraphicsExportSetInputGWorld, 1,
26835      PyDoc_STR("(GraphicsExportComponent ci, GWorldPtr gworld) -> (ComponentResult _rv)")},
26836     {"GraphicsExportGetInputGWorld", (PyCFunction)Qt_GraphicsExportGetInputGWorld, 1,
26837      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, GWorldPtr gworld)")},
26838     {"GraphicsExportSetInputPixmap", (PyCFunction)Qt_GraphicsExportSetInputPixmap, 1,
26839      PyDoc_STR("(GraphicsExportComponent ci, PixMapHandle pixmap) -> (ComponentResult _rv)")},
26840     {"GraphicsExportGetInputPixmap", (PyCFunction)Qt_GraphicsExportGetInputPixmap, 1,
26841      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, PixMapHandle pixmap)")},
26842     {"GraphicsExportSetInputOffsetAndLimit", (PyCFunction)Qt_GraphicsExportSetInputOffsetAndLimit, 1,
26843      PyDoc_STR("(GraphicsExportComponent ci, unsigned long offset, unsigned long limit) -> (ComponentResult _rv)")},
26844     {"GraphicsExportGetInputOffsetAndLimit", (PyCFunction)Qt_GraphicsExportGetInputOffsetAndLimit, 1,
26845      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long offset, unsigned long limit)")},
26846     {"GraphicsExportMayExporterReadInputData", (PyCFunction)Qt_GraphicsExportMayExporterReadInputData, 1,
26847      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Boolean mayReadInputData)")},
26848     {"GraphicsExportGetInputDataSize", (PyCFunction)Qt_GraphicsExportGetInputDataSize, 1,
26849      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long size)")},
26850     {"GraphicsExportReadInputData", (PyCFunction)Qt_GraphicsExportReadInputData, 1,
26851      PyDoc_STR("(GraphicsExportComponent ci, void * dataPtr, unsigned long dataOffset, unsigned long dataSize) -> (ComponentResult _rv)")},
26852     {"GraphicsExportGetInputImageDescription", (PyCFunction)Qt_GraphicsExportGetInputImageDescription, 1,
26853      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, ImageDescriptionHandle desc)")},
26854     {"GraphicsExportGetInputImageDimensions", (PyCFunction)Qt_GraphicsExportGetInputImageDimensions, 1,
26855      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Rect dimensions)")},
26856     {"GraphicsExportGetInputImageDepth", (PyCFunction)Qt_GraphicsExportGetInputImageDepth, 1,
26857      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, long inputDepth)")},
26858     {"GraphicsExportDrawInputImage", (PyCFunction)Qt_GraphicsExportDrawInputImage, 1,
26859      PyDoc_STR("(GraphicsExportComponent ci, CGrafPtr gw, GDHandle gd, Rect srcRect, Rect dstRect) -> (ComponentResult _rv)")},
26860     {"GraphicsExportSetOutputDataReference", (PyCFunction)Qt_GraphicsExportSetOutputDataReference, 1,
26861      PyDoc_STR("(GraphicsExportComponent ci, Handle dataRef, OSType dataRefType) -> (ComponentResult _rv)")},
26862     {"GraphicsExportGetOutputDataReference", (PyCFunction)Qt_GraphicsExportGetOutputDataReference, 1,
26863      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Handle dataRef, OSType dataRefType)")},
26864     {"GraphicsExportSetOutputFile", (PyCFunction)Qt_GraphicsExportSetOutputFile, 1,
26865      PyDoc_STR("(GraphicsExportComponent ci, FSSpec theFile) -> (ComponentResult _rv)")},
26866     {"GraphicsExportGetOutputFile", (PyCFunction)Qt_GraphicsExportGetOutputFile, 1,
26867      PyDoc_STR("(GraphicsExportComponent ci, FSSpec theFile) -> (ComponentResult _rv)")},
26868     {"GraphicsExportSetOutputHandle", (PyCFunction)Qt_GraphicsExportSetOutputHandle, 1,
26869      PyDoc_STR("(GraphicsExportComponent ci, Handle h) -> (ComponentResult _rv)")},
26870     {"GraphicsExportGetOutputHandle", (PyCFunction)Qt_GraphicsExportGetOutputHandle, 1,
26871      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Handle h)")},
26872     {"GraphicsExportSetOutputOffsetAndMaxSize", (PyCFunction)Qt_GraphicsExportSetOutputOffsetAndMaxSize, 1,
26873      PyDoc_STR("(GraphicsExportComponent ci, unsigned long offset, unsigned long maxSize, Boolean truncateFile) -> (ComponentResult _rv)")},
26874     {"GraphicsExportGetOutputOffsetAndMaxSize", (PyCFunction)Qt_GraphicsExportGetOutputOffsetAndMaxSize, 1,
26875      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long offset, unsigned long maxSize, Boolean truncateFile)")},
26876     {"GraphicsExportSetOutputFileTypeAndCreator", (PyCFunction)Qt_GraphicsExportSetOutputFileTypeAndCreator, 1,
26877      PyDoc_STR("(GraphicsExportComponent ci, OSType fileType, OSType fileCreator) -> (ComponentResult _rv)")},
26878     {"GraphicsExportGetOutputFileTypeAndCreator", (PyCFunction)Qt_GraphicsExportGetOutputFileTypeAndCreator, 1,
26879      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, OSType fileType, OSType fileCreator)")},
26880     {"GraphicsExportSetOutputMark", (PyCFunction)Qt_GraphicsExportSetOutputMark, 1,
26881      PyDoc_STR("(GraphicsExportComponent ci, unsigned long mark) -> (ComponentResult _rv)")},
26882     {"GraphicsExportGetOutputMark", (PyCFunction)Qt_GraphicsExportGetOutputMark, 1,
26883      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, unsigned long mark)")},
26884     {"GraphicsExportReadOutputData", (PyCFunction)Qt_GraphicsExportReadOutputData, 1,
26885      PyDoc_STR("(GraphicsExportComponent ci, void * dataPtr, unsigned long dataOffset, unsigned long dataSize) -> (ComponentResult _rv)")},
26886     {"GraphicsExportSetThumbnailEnabled", (PyCFunction)Qt_GraphicsExportSetThumbnailEnabled, 1,
26887      PyDoc_STR("(GraphicsExportComponent ci, Boolean enableThumbnail, long maxThumbnailWidth, long maxThumbnailHeight) -> (ComponentResult _rv)")},
26888     {"GraphicsExportGetThumbnailEnabled", (PyCFunction)Qt_GraphicsExportGetThumbnailEnabled, 1,
26889      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Boolean thumbnailEnabled, long maxThumbnailWidth, long maxThumbnailHeight)")},
26890     {"GraphicsExportSetExifEnabled", (PyCFunction)Qt_GraphicsExportSetExifEnabled, 1,
26891      PyDoc_STR("(GraphicsExportComponent ci, Boolean enableExif) -> (ComponentResult _rv)")},
26892     {"GraphicsExportGetExifEnabled", (PyCFunction)Qt_GraphicsExportGetExifEnabled, 1,
26893      PyDoc_STR("(GraphicsExportComponent ci) -> (ComponentResult _rv, Boolean exifEnabled)")},
26894     {"ImageTranscoderBeginSequence", (PyCFunction)Qt_ImageTranscoderBeginSequence, 1,
26895      PyDoc_STR("(ImageTranscoderComponent itc, ImageDescriptionHandle srcDesc, void * data, long dataSize) -> (ComponentResult _rv, ImageDescriptionHandle dstDesc)")},
26896     {"ImageTranscoderDisposeData", (PyCFunction)Qt_ImageTranscoderDisposeData, 1,
26897      PyDoc_STR("(ImageTranscoderComponent itc, void * dstData) -> (ComponentResult _rv)")},
26898     {"ImageTranscoderEndSequence", (PyCFunction)Qt_ImageTranscoderEndSequence, 1,
26899      PyDoc_STR("(ImageTranscoderComponent itc) -> (ComponentResult _rv)")},
26900     {"ClockGetTime", (PyCFunction)Qt_ClockGetTime, 1,
26901      PyDoc_STR("(ComponentInstance aClock) -> (ComponentResult _rv, TimeRecord out)")},
26902     {"ClockSetTimeBase", (PyCFunction)Qt_ClockSetTimeBase, 1,
26903      PyDoc_STR("(ComponentInstance aClock, TimeBase tb) -> (ComponentResult _rv)")},
26904     {"ClockGetRate", (PyCFunction)Qt_ClockGetRate, 1,
26905      PyDoc_STR("(ComponentInstance aClock) -> (ComponentResult _rv, Fixed rate)")},
26906     {"SCPositionRect", (PyCFunction)Qt_SCPositionRect, 1,
26907      PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv, Rect rp, Point where)")},
26908     {"SCPositionDialog", (PyCFunction)Qt_SCPositionDialog, 1,
26909      PyDoc_STR("(ComponentInstance ci, short id) -> (ComponentResult _rv, Point where)")},
26910     {"SCSetTestImagePictHandle", (PyCFunction)Qt_SCSetTestImagePictHandle, 1,
26911      PyDoc_STR("(ComponentInstance ci, PicHandle testPict, short testFlags) -> (ComponentResult _rv, Rect testRect)")},
26912     {"SCSetTestImagePictFile", (PyCFunction)Qt_SCSetTestImagePictFile, 1,
26913      PyDoc_STR("(ComponentInstance ci, short testFileRef, short testFlags) -> (ComponentResult _rv, Rect testRect)")},
26914     {"SCSetTestImagePixMap", (PyCFunction)Qt_SCSetTestImagePixMap, 1,
26915      PyDoc_STR("(ComponentInstance ci, PixMapHandle testPixMap, short testFlags) -> (ComponentResult _rv, Rect testRect)")},
26916     {"SCGetBestDeviceRect", (PyCFunction)Qt_SCGetBestDeviceRect, 1,
26917      PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv, Rect r)")},
26918     {"SCRequestImageSettings", (PyCFunction)Qt_SCRequestImageSettings, 1,
26919      PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv)")},
26920     {"SCCompressImage", (PyCFunction)Qt_SCCompressImage, 1,
26921      PyDoc_STR("(ComponentInstance ci, PixMapHandle src, Rect srcRect) -> (ComponentResult _rv, ImageDescriptionHandle desc, Handle data)")},
26922     {"SCCompressPicture", (PyCFunction)Qt_SCCompressPicture, 1,
26923      PyDoc_STR("(ComponentInstance ci, PicHandle srcPicture, PicHandle dstPicture) -> (ComponentResult _rv)")},
26924     {"SCCompressPictureFile", (PyCFunction)Qt_SCCompressPictureFile, 1,
26925      PyDoc_STR("(ComponentInstance ci, short srcRefNum, short dstRefNum) -> (ComponentResult _rv)")},
26926     {"SCRequestSequenceSettings", (PyCFunction)Qt_SCRequestSequenceSettings, 1,
26927      PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv)")},
26928     {"SCCompressSequenceBegin", (PyCFunction)Qt_SCCompressSequenceBegin, 1,
26929      PyDoc_STR("(ComponentInstance ci, PixMapHandle src, Rect srcRect) -> (ComponentResult _rv, ImageDescriptionHandle desc)")},
26930     {"SCCompressSequenceFrame", (PyCFunction)Qt_SCCompressSequenceFrame, 1,
26931      PyDoc_STR("(ComponentInstance ci, PixMapHandle src, Rect srcRect) -> (ComponentResult _rv, Handle data, long dataSize, short notSyncFlag)")},
26932     {"SCCompressSequenceEnd", (PyCFunction)Qt_SCCompressSequenceEnd, 1,
26933      PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv)")},
26934     {"SCDefaultPictHandleSettings", (PyCFunction)Qt_SCDefaultPictHandleSettings, 1,
26935      PyDoc_STR("(ComponentInstance ci, PicHandle srcPicture, short motion) -> (ComponentResult _rv)")},
26936     {"SCDefaultPictFileSettings", (PyCFunction)Qt_SCDefaultPictFileSettings, 1,
26937      PyDoc_STR("(ComponentInstance ci, short srcRef, short motion) -> (ComponentResult _rv)")},
26938     {"SCDefaultPixMapSettings", (PyCFunction)Qt_SCDefaultPixMapSettings, 1,
26939      PyDoc_STR("(ComponentInstance ci, PixMapHandle src, short motion) -> (ComponentResult _rv)")},
26940     {"SCGetInfo", (PyCFunction)Qt_SCGetInfo, 1,
26941      PyDoc_STR("(ComponentInstance ci, OSType infoType, void * info) -> (ComponentResult _rv)")},
26942     {"SCSetInfo", (PyCFunction)Qt_SCSetInfo, 1,
26943      PyDoc_STR("(ComponentInstance ci, OSType infoType, void * info) -> (ComponentResult _rv)")},
26944     {"SCSetCompressFlags", (PyCFunction)Qt_SCSetCompressFlags, 1,
26945      PyDoc_STR("(ComponentInstance ci, long flags) -> (ComponentResult _rv)")},
26946     {"SCGetCompressFlags", (PyCFunction)Qt_SCGetCompressFlags, 1,
26947      PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv, long flags)")},
26948     {"SCGetSettingsAsText", (PyCFunction)Qt_SCGetSettingsAsText, 1,
26949      PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv, Handle text)")},
26950     {"SCAsyncIdle", (PyCFunction)Qt_SCAsyncIdle, 1,
26951      PyDoc_STR("(ComponentInstance ci) -> (ComponentResult _rv)")},
26952     {"TweenerReset", (PyCFunction)Qt_TweenerReset, 1,
26953      PyDoc_STR("(TweenerComponent tc) -> (ComponentResult _rv)")},
26954     {"TCGetSourceRef", (PyCFunction)Qt_TCGetSourceRef, 1,
26955      PyDoc_STR("(MediaHandler mh, TimeCodeDescriptionHandle tcdH) -> (HandlerError _rv, UserData srefH)")},
26956     {"TCSetSourceRef", (PyCFunction)Qt_TCSetSourceRef, 1,
26957      PyDoc_STR("(MediaHandler mh, TimeCodeDescriptionHandle tcdH, UserData srefH) -> (HandlerError _rv)")},
26958     {"TCSetTimeCodeFlags", (PyCFunction)Qt_TCSetTimeCodeFlags, 1,
26959      PyDoc_STR("(MediaHandler mh, long flags, long flagsMask) -> (HandlerError _rv)")},
26960     {"TCGetTimeCodeFlags", (PyCFunction)Qt_TCGetTimeCodeFlags, 1,
26961      PyDoc_STR("(MediaHandler mh) -> (HandlerError _rv, long flags)")},
26962     {"MovieImportHandle", (PyCFunction)Qt_MovieImportHandle, 1,
26963      PyDoc_STR("(MovieImportComponent ci, Handle dataH, Movie theMovie, Track targetTrack, TimeValue atTime, long inFlags) -> (ComponentResult _rv, Track usedTrack, TimeValue addedDuration, long outFlags)")},
26964     {"MovieImportFile", (PyCFunction)Qt_MovieImportFile, 1,
26965      PyDoc_STR("(MovieImportComponent ci, FSSpec theFile, Movie theMovie, Track targetTrack, TimeValue atTime, long inFlags) -> (ComponentResult _rv, Track usedTrack, TimeValue addedDuration, long outFlags)")},
26966     {"MovieImportSetSampleDuration", (PyCFunction)Qt_MovieImportSetSampleDuration, 1,
26967      PyDoc_STR("(MovieImportComponent ci, TimeValue duration, TimeScale scale) -> (ComponentResult _rv)")},
26968     {"MovieImportSetSampleDescription", (PyCFunction)Qt_MovieImportSetSampleDescription, 1,
26969      PyDoc_STR("(MovieImportComponent ci, SampleDescriptionHandle desc, OSType mediaType) -> (ComponentResult _rv)")},
26970     {"MovieImportSetMediaFile", (PyCFunction)Qt_MovieImportSetMediaFile, 1,
26971      PyDoc_STR("(MovieImportComponent ci, AliasHandle alias) -> (ComponentResult _rv)")},
26972     {"MovieImportSetDimensions", (PyCFunction)Qt_MovieImportSetDimensions, 1,
26973      PyDoc_STR("(MovieImportComponent ci, Fixed width, Fixed height) -> (ComponentResult _rv)")},
26974     {"MovieImportSetChunkSize", (PyCFunction)Qt_MovieImportSetChunkSize, 1,
26975      PyDoc_STR("(MovieImportComponent ci, long chunkSize) -> (ComponentResult _rv)")},
26976     {"MovieImportSetAuxiliaryData", (PyCFunction)Qt_MovieImportSetAuxiliaryData, 1,
26977      PyDoc_STR("(MovieImportComponent ci, Handle data, OSType handleType) -> (ComponentResult _rv)")},
26978     {"MovieImportSetFromScrap", (PyCFunction)Qt_MovieImportSetFromScrap, 1,
26979      PyDoc_STR("(MovieImportComponent ci, Boolean fromScrap) -> (ComponentResult _rv)")},
26980     {"MovieImportDoUserDialog", (PyCFunction)Qt_MovieImportDoUserDialog, 1,
26981      PyDoc_STR("(MovieImportComponent ci, FSSpec theFile, Handle theData) -> (ComponentResult _rv, Boolean canceled)")},
26982     {"MovieImportSetDuration", (PyCFunction)Qt_MovieImportSetDuration, 1,
26983      PyDoc_STR("(MovieImportComponent ci, TimeValue duration) -> (ComponentResult _rv)")},
26984     {"MovieImportGetAuxiliaryDataType", (PyCFunction)Qt_MovieImportGetAuxiliaryDataType, 1,
26985      PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, OSType auxType)")},
26986     {"MovieImportValidate", (PyCFunction)Qt_MovieImportValidate, 1,
26987      PyDoc_STR("(MovieImportComponent ci, FSSpec theFile, Handle theData) -> (ComponentResult _rv, Boolean valid)")},
26988     {"MovieImportGetFileType", (PyCFunction)Qt_MovieImportGetFileType, 1,
26989      PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, OSType fileType)")},
26990     {"MovieImportDataRef", (PyCFunction)Qt_MovieImportDataRef, 1,
26991      PyDoc_STR("(MovieImportComponent ci, Handle dataRef, OSType dataRefType, Movie theMovie, Track targetTrack, TimeValue atTime, long inFlags) -> (ComponentResult _rv, Track usedTrack, TimeValue addedDuration, long outFlags)")},
26992     {"MovieImportGetSampleDescription", (PyCFunction)Qt_MovieImportGetSampleDescription, 1,
26993      PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, SampleDescriptionHandle desc, OSType mediaType)")},
26994     {"MovieImportSetOffsetAndLimit", (PyCFunction)Qt_MovieImportSetOffsetAndLimit, 1,
26995      PyDoc_STR("(MovieImportComponent ci, unsigned long offset, unsigned long limit) -> (ComponentResult _rv)")},
26996     {"MovieImportSetOffsetAndLimit64", (PyCFunction)Qt_MovieImportSetOffsetAndLimit64, 1,
26997      PyDoc_STR("(MovieImportComponent ci, wide offset, wide limit) -> (ComponentResult _rv)")},
26998     {"MovieImportIdle", (PyCFunction)Qt_MovieImportIdle, 1,
26999      PyDoc_STR("(MovieImportComponent ci, long inFlags) -> (ComponentResult _rv, long outFlags)")},
27000     {"MovieImportValidateDataRef", (PyCFunction)Qt_MovieImportValidateDataRef, 1,
27001      PyDoc_STR("(MovieImportComponent ci, Handle dataRef, OSType dataRefType) -> (ComponentResult _rv, UInt8 valid)")},
27002     {"MovieImportGetLoadState", (PyCFunction)Qt_MovieImportGetLoadState, 1,
27003      PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, long importerLoadState)")},
27004     {"MovieImportGetMaxLoadedTime", (PyCFunction)Qt_MovieImportGetMaxLoadedTime, 1,
27005      PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, TimeValue time)")},
27006     {"MovieImportEstimateCompletionTime", (PyCFunction)Qt_MovieImportEstimateCompletionTime, 1,
27007      PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, TimeRecord time)")},
27008     {"MovieImportSetDontBlock", (PyCFunction)Qt_MovieImportSetDontBlock, 1,
27009      PyDoc_STR("(MovieImportComponent ci, Boolean dontBlock) -> (ComponentResult _rv)")},
27010     {"MovieImportGetDontBlock", (PyCFunction)Qt_MovieImportGetDontBlock, 1,
27011      PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, Boolean willBlock)")},
27012     {"MovieImportSetIdleManager", (PyCFunction)Qt_MovieImportSetIdleManager, 1,
27013      PyDoc_STR("(MovieImportComponent ci, IdleManager im) -> (ComponentResult _rv)")},
27014     {"MovieImportSetNewMovieFlags", (PyCFunction)Qt_MovieImportSetNewMovieFlags, 1,
27015      PyDoc_STR("(MovieImportComponent ci, long newMovieFlags) -> (ComponentResult _rv)")},
27016     {"MovieImportGetDestinationMediaType", (PyCFunction)Qt_MovieImportGetDestinationMediaType, 1,
27017      PyDoc_STR("(MovieImportComponent ci) -> (ComponentResult _rv, OSType mediaType)")},
27018     {"MovieExportToHandle", (PyCFunction)Qt_MovieExportToHandle, 1,
27019      PyDoc_STR("(MovieExportComponent ci, Handle dataH, Movie theMovie, Track onlyThisTrack, TimeValue startTime, TimeValue duration) -> (ComponentResult _rv)")},
27020     {"MovieExportToFile", (PyCFunction)Qt_MovieExportToFile, 1,
27021      PyDoc_STR("(MovieExportComponent ci, FSSpec theFile, Movie theMovie, Track onlyThisTrack, TimeValue startTime, TimeValue duration) -> (ComponentResult _rv)")},
27022     {"MovieExportGetAuxiliaryData", (PyCFunction)Qt_MovieExportGetAuxiliaryData, 1,
27023      PyDoc_STR("(MovieExportComponent ci, Handle dataH) -> (ComponentResult _rv, OSType handleType)")},
27024     {"MovieExportSetSampleDescription", (PyCFunction)Qt_MovieExportSetSampleDescription, 1,
27025      PyDoc_STR("(MovieExportComponent ci, SampleDescriptionHandle desc, OSType mediaType) -> (ComponentResult _rv)")},
27026     {"MovieExportDoUserDialog", (PyCFunction)Qt_MovieExportDoUserDialog, 1,
27027      PyDoc_STR("(MovieExportComponent ci, Movie theMovie, Track onlyThisTrack, TimeValue startTime, TimeValue duration) -> (ComponentResult _rv, Boolean canceled)")},
27028     {"MovieExportGetCreatorType", (PyCFunction)Qt_MovieExportGetCreatorType, 1,
27029      PyDoc_STR("(MovieExportComponent ci) -> (ComponentResult _rv, OSType creator)")},
27030     {"MovieExportToDataRef", (PyCFunction)Qt_MovieExportToDataRef, 1,
27031      PyDoc_STR("(MovieExportComponent ci, Handle dataRef, OSType dataRefType, Movie theMovie, Track onlyThisTrack, TimeValue startTime, TimeValue duration) -> (ComponentResult _rv)")},
27032     {"MovieExportFromProceduresToDataRef", (PyCFunction)Qt_MovieExportFromProceduresToDataRef, 1,
27033      PyDoc_STR("(MovieExportComponent ci, Handle dataRef, OSType dataRefType) -> (ComponentResult _rv)")},
27034     {"MovieExportValidate", (PyCFunction)Qt_MovieExportValidate, 1,
27035      PyDoc_STR("(MovieExportComponent ci, Movie theMovie, Track onlyThisTrack) -> (ComponentResult _rv, Boolean valid)")},
27036     {"MovieExportGetFileNameExtension", (PyCFunction)Qt_MovieExportGetFileNameExtension, 1,
27037      PyDoc_STR("(MovieExportComponent ci) -> (ComponentResult _rv, OSType extension)")},
27038     {"MovieExportGetShortFileTypeString", (PyCFunction)Qt_MovieExportGetShortFileTypeString, 1,
27039      PyDoc_STR("(MovieExportComponent ci, Str255 typeString) -> (ComponentResult _rv)")},
27040     {"MovieExportGetSourceMediaType", (PyCFunction)Qt_MovieExportGetSourceMediaType, 1,
27041      PyDoc_STR("(MovieExportComponent ci) -> (ComponentResult _rv, OSType mediaType)")},
27042     {"TextExportGetTimeFraction", (PyCFunction)Qt_TextExportGetTimeFraction, 1,
27043      PyDoc_STR("(TextExportComponent ci) -> (ComponentResult _rv, long movieTimeFraction)")},
27044     {"TextExportSetTimeFraction", (PyCFunction)Qt_TextExportSetTimeFraction, 1,
27045      PyDoc_STR("(TextExportComponent ci, long movieTimeFraction) -> (ComponentResult _rv)")},
27046     {"TextExportGetSettings", (PyCFunction)Qt_TextExportGetSettings, 1,
27047      PyDoc_STR("(TextExportComponent ci) -> (ComponentResult _rv, long setting)")},
27048     {"TextExportSetSettings", (PyCFunction)Qt_TextExportSetSettings, 1,
27049      PyDoc_STR("(TextExportComponent ci, long setting) -> (ComponentResult _rv)")},
27050     {"MIDIImportGetSettings", (PyCFunction)Qt_MIDIImportGetSettings, 1,
27051      PyDoc_STR("(TextExportComponent ci) -> (ComponentResult _rv, long setting)")},
27052     {"MIDIImportSetSettings", (PyCFunction)Qt_MIDIImportSetSettings, 1,
27053      PyDoc_STR("(TextExportComponent ci, long setting) -> (ComponentResult _rv)")},
27054     {"GraphicsImageImportSetSequenceEnabled", (PyCFunction)Qt_GraphicsImageImportSetSequenceEnabled, 1,
27055      PyDoc_STR("(GraphicImageMovieImportComponent ci, Boolean enable) -> (ComponentResult _rv)")},
27056     {"GraphicsImageImportGetSequenceEnabled", (PyCFunction)Qt_GraphicsImageImportGetSequenceEnabled, 1,
27057      PyDoc_STR("(GraphicImageMovieImportComponent ci) -> (ComponentResult _rv, Boolean enable)")},
27058     {"PreviewShowData", (PyCFunction)Qt_PreviewShowData, 1,
27059      PyDoc_STR("(pnotComponent p, OSType dataType, Handle data, Rect inHere) -> (ComponentResult _rv)")},
27060     {"PreviewMakePreviewReference", (PyCFunction)Qt_PreviewMakePreviewReference, 1,
27061      PyDoc_STR("(pnotComponent p, FSSpec sourceFile) -> (ComponentResult _rv, OSType previewType, short resID)")},
27062     {"PreviewEvent", (PyCFunction)Qt_PreviewEvent, 1,
27063      PyDoc_STR("(pnotComponent p) -> (ComponentResult _rv, EventRecord e, Boolean handledEvent)")},
27064     {"DataCodecDecompress", (PyCFunction)Qt_DataCodecDecompress, 1,
27065      PyDoc_STR("(DataCodecComponent dc, void * srcData, UInt32 srcSize, void * dstData, UInt32 dstBufferSize) -> (ComponentResult _rv)")},
27066     {"DataCodecGetCompressBufferSize", (PyCFunction)Qt_DataCodecGetCompressBufferSize, 1,
27067      PyDoc_STR("(DataCodecComponent dc, UInt32 srcSize) -> (ComponentResult _rv, UInt32 dstSize)")},
27068     {"DataCodecCompress", (PyCFunction)Qt_DataCodecCompress, 1,
27069      PyDoc_STR("(DataCodecComponent dc, void * srcData, UInt32 srcSize, void * dstData, UInt32 dstBufferSize) -> (ComponentResult _rv, UInt32 actualDstSize, UInt32 decompressSlop)")},
27070     {"DataCodecBeginInterruptSafe", (PyCFunction)Qt_DataCodecBeginInterruptSafe, 1,
27071      PyDoc_STR("(DataCodecComponent dc, unsigned long maxSrcSize) -> (ComponentResult _rv)")},
27072     {"DataCodecEndInterruptSafe", (PyCFunction)Qt_DataCodecEndInterruptSafe, 1,
27073      PyDoc_STR("(DataCodecComponent dc) -> (ComponentResult _rv)")},
27074     {"DataHGetData", (PyCFunction)Qt_DataHGetData, 1,
27075      PyDoc_STR("(DataHandler dh, Handle h, long hOffset, long offset, long size) -> (ComponentResult _rv)")},
27076     {"DataHPutData", (PyCFunction)Qt_DataHPutData, 1,
27077      PyDoc_STR("(DataHandler dh, Handle h, long hOffset, long size) -> (ComponentResult _rv, long offset)")},
27078     {"DataHFlushData", (PyCFunction)Qt_DataHFlushData, 1,
27079      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
27080     {"DataHOpenForWrite", (PyCFunction)Qt_DataHOpenForWrite, 1,
27081      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
27082     {"DataHCloseForWrite", (PyCFunction)Qt_DataHCloseForWrite, 1,
27083      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
27084     {"DataHOpenForRead", (PyCFunction)Qt_DataHOpenForRead, 1,
27085      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
27086     {"DataHCloseForRead", (PyCFunction)Qt_DataHCloseForRead, 1,
27087      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
27088     {"DataHSetDataRef", (PyCFunction)Qt_DataHSetDataRef, 1,
27089      PyDoc_STR("(DataHandler dh, Handle dataRef) -> (ComponentResult _rv)")},
27090     {"DataHGetDataRef", (PyCFunction)Qt_DataHGetDataRef, 1,
27091      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, Handle dataRef)")},
27092     {"DataHCompareDataRef", (PyCFunction)Qt_DataHCompareDataRef, 1,
27093      PyDoc_STR("(DataHandler dh, Handle dataRef) -> (ComponentResult _rv, Boolean equal)")},
27094     {"DataHTask", (PyCFunction)Qt_DataHTask, 1,
27095      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
27096     {"DataHFinishData", (PyCFunction)Qt_DataHFinishData, 1,
27097      PyDoc_STR("(DataHandler dh, Ptr PlaceToPutDataPtr, Boolean Cancel) -> (ComponentResult _rv)")},
27098     {"DataHFlushCache", (PyCFunction)Qt_DataHFlushCache, 1,
27099      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
27100     {"DataHResolveDataRef", (PyCFunction)Qt_DataHResolveDataRef, 1,
27101      PyDoc_STR("(DataHandler dh, Handle theDataRef, Boolean userInterfaceAllowed) -> (ComponentResult _rv, Boolean wasChanged)")},
27102     {"DataHGetFileSize", (PyCFunction)Qt_DataHGetFileSize, 1,
27103      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, long fileSize)")},
27104     {"DataHCanUseDataRef", (PyCFunction)Qt_DataHCanUseDataRef, 1,
27105      PyDoc_STR("(DataHandler dh, Handle dataRef) -> (ComponentResult _rv, long useFlags)")},
27106     {"DataHPreextend", (PyCFunction)Qt_DataHPreextend, 1,
27107      PyDoc_STR("(DataHandler dh, unsigned long maxToAdd) -> (ComponentResult _rv, unsigned long spaceAdded)")},
27108     {"DataHSetFileSize", (PyCFunction)Qt_DataHSetFileSize, 1,
27109      PyDoc_STR("(DataHandler dh, long fileSize) -> (ComponentResult _rv)")},
27110     {"DataHGetFreeSpace", (PyCFunction)Qt_DataHGetFreeSpace, 1,
27111      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, unsigned long freeSize)")},
27112     {"DataHCreateFile", (PyCFunction)Qt_DataHCreateFile, 1,
27113      PyDoc_STR("(DataHandler dh, OSType creator, Boolean deleteExisting) -> (ComponentResult _rv)")},
27114     {"DataHGetPreferredBlockSize", (PyCFunction)Qt_DataHGetPreferredBlockSize, 1,
27115      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, long blockSize)")},
27116     {"DataHGetDeviceIndex", (PyCFunction)Qt_DataHGetDeviceIndex, 1,
27117      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, long deviceIndex)")},
27118     {"DataHIsStreamingDataHandler", (PyCFunction)Qt_DataHIsStreamingDataHandler, 1,
27119      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, Boolean yes)")},
27120     {"DataHGetDataInBuffer", (PyCFunction)Qt_DataHGetDataInBuffer, 1,
27121      PyDoc_STR("(DataHandler dh, long startOffset) -> (ComponentResult _rv, long size)")},
27122     {"DataHGetScheduleAheadTime", (PyCFunction)Qt_DataHGetScheduleAheadTime, 1,
27123      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, long millisecs)")},
27124     {"DataHSetCacheSizeLimit", (PyCFunction)Qt_DataHSetCacheSizeLimit, 1,
27125      PyDoc_STR("(DataHandler dh, Size cacheSizeLimit) -> (ComponentResult _rv)")},
27126     {"DataHGetCacheSizeLimit", (PyCFunction)Qt_DataHGetCacheSizeLimit, 1,
27127      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, Size cacheSizeLimit)")},
27128     {"DataHGetMovie", (PyCFunction)Qt_DataHGetMovie, 1,
27129      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, Movie theMovie, short id)")},
27130     {"DataHAddMovie", (PyCFunction)Qt_DataHAddMovie, 1,
27131      PyDoc_STR("(DataHandler dh, Movie theMovie) -> (ComponentResult _rv, short id)")},
27132     {"DataHUpdateMovie", (PyCFunction)Qt_DataHUpdateMovie, 1,
27133      PyDoc_STR("(DataHandler dh, Movie theMovie, short id) -> (ComponentResult _rv)")},
27134     {"DataHDoesBuffer", (PyCFunction)Qt_DataHDoesBuffer, 1,
27135      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, Boolean buffersReads, Boolean buffersWrites)")},
27136     {"DataHGetFileName", (PyCFunction)Qt_DataHGetFileName, 1,
27137      PyDoc_STR("(DataHandler dh, Str255 str) -> (ComponentResult _rv)")},
27138     {"DataHGetAvailableFileSize", (PyCFunction)Qt_DataHGetAvailableFileSize, 1,
27139      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, long fileSize)")},
27140     {"DataHGetMacOSFileType", (PyCFunction)Qt_DataHGetMacOSFileType, 1,
27141      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, OSType fileType)")},
27142     {"DataHGetMIMEType", (PyCFunction)Qt_DataHGetMIMEType, 1,
27143      PyDoc_STR("(DataHandler dh, Str255 mimeType) -> (ComponentResult _rv)")},
27144     {"DataHSetDataRefWithAnchor", (PyCFunction)Qt_DataHSetDataRefWithAnchor, 1,
27145      PyDoc_STR("(DataHandler dh, Handle anchorDataRef, OSType dataRefType, Handle dataRef) -> (ComponentResult _rv)")},
27146     {"DataHGetDataRefWithAnchor", (PyCFunction)Qt_DataHGetDataRefWithAnchor, 1,
27147      PyDoc_STR("(DataHandler dh, Handle anchorDataRef, OSType dataRefType) -> (ComponentResult _rv, Handle dataRef)")},
27148     {"DataHSetMacOSFileType", (PyCFunction)Qt_DataHSetMacOSFileType, 1,
27149      PyDoc_STR("(DataHandler dh, OSType fileType) -> (ComponentResult _rv)")},
27150     {"DataHSetTimeBase", (PyCFunction)Qt_DataHSetTimeBase, 1,
27151      PyDoc_STR("(DataHandler dh, TimeBase tb) -> (ComponentResult _rv)")},
27152     {"DataHGetInfoFlags", (PyCFunction)Qt_DataHGetInfoFlags, 1,
27153      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, UInt32 flags)")},
27154     {"DataHGetFileSize64", (PyCFunction)Qt_DataHGetFileSize64, 1,
27155      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, wide fileSize)")},
27156     {"DataHPreextend64", (PyCFunction)Qt_DataHPreextend64, 1,
27157      PyDoc_STR("(DataHandler dh, wide maxToAdd) -> (ComponentResult _rv, wide spaceAdded)")},
27158     {"DataHSetFileSize64", (PyCFunction)Qt_DataHSetFileSize64, 1,
27159      PyDoc_STR("(DataHandler dh, wide fileSize) -> (ComponentResult _rv)")},
27160     {"DataHGetFreeSpace64", (PyCFunction)Qt_DataHGetFreeSpace64, 1,
27161      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, wide freeSize)")},
27162     {"DataHAppend64", (PyCFunction)Qt_DataHAppend64, 1,
27163      PyDoc_STR("(DataHandler dh, void * data, unsigned long size) -> (ComponentResult _rv, wide fileOffset)")},
27164     {"DataHPollRead", (PyCFunction)Qt_DataHPollRead, 1,
27165      PyDoc_STR("(DataHandler dh, void * dataPtr) -> (ComponentResult _rv, UInt32 dataSizeSoFar)")},
27166     {"DataHGetDataAvailability", (PyCFunction)Qt_DataHGetDataAvailability, 1,
27167      PyDoc_STR("(DataHandler dh, long offset, long len) -> (ComponentResult _rv, long missing_offset, long missing_len)")},
27168     {"DataHGetDataRefAsType", (PyCFunction)Qt_DataHGetDataRefAsType, 1,
27169      PyDoc_STR("(DataHandler dh, OSType requestedType) -> (ComponentResult _rv, Handle dataRef)")},
27170     {"DataHSetDataRefExtension", (PyCFunction)Qt_DataHSetDataRefExtension, 1,
27171      PyDoc_STR("(DataHandler dh, Handle extension, OSType idType) -> (ComponentResult _rv)")},
27172     {"DataHGetDataRefExtension", (PyCFunction)Qt_DataHGetDataRefExtension, 1,
27173      PyDoc_STR("(DataHandler dh, OSType idType) -> (ComponentResult _rv, Handle extension)")},
27174     {"DataHGetMovieWithFlags", (PyCFunction)Qt_DataHGetMovieWithFlags, 1,
27175      PyDoc_STR("(DataHandler dh, short flags) -> (ComponentResult _rv, Movie theMovie, short id)")},
27176     {"DataHGetFileTypeOrdering", (PyCFunction)Qt_DataHGetFileTypeOrdering, 1,
27177      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, DataHFileTypeOrderingHandle orderingListHandle)")},
27178     {"DataHCreateFileWithFlags", (PyCFunction)Qt_DataHCreateFileWithFlags, 1,
27179      PyDoc_STR("(DataHandler dh, OSType creator, Boolean deleteExisting, UInt32 flags) -> (ComponentResult _rv)")},
27180     {"DataHGetInfo", (PyCFunction)Qt_DataHGetInfo, 1,
27181      PyDoc_STR("(DataHandler dh, OSType what, void * info) -> (ComponentResult _rv)")},
27182     {"DataHSetIdleManager", (PyCFunction)Qt_DataHSetIdleManager, 1,
27183      PyDoc_STR("(DataHandler dh, IdleManager im) -> (ComponentResult _rv)")},
27184     {"DataHDeleteFile", (PyCFunction)Qt_DataHDeleteFile, 1,
27185      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv)")},
27186     {"DataHSetMovieUsageFlags", (PyCFunction)Qt_DataHSetMovieUsageFlags, 1,
27187      PyDoc_STR("(DataHandler dh, long flags) -> (ComponentResult _rv)")},
27188     {"DataHUseTemporaryDataRef", (PyCFunction)Qt_DataHUseTemporaryDataRef, 1,
27189      PyDoc_STR("(DataHandler dh, long inFlags) -> (ComponentResult _rv)")},
27190     {"DataHGetTemporaryDataRefCapabilities", (PyCFunction)Qt_DataHGetTemporaryDataRefCapabilities, 1,
27191      PyDoc_STR("(DataHandler dh) -> (ComponentResult _rv, long outUnderstoodFlags)")},
27192     {"DataHRenameFile", (PyCFunction)Qt_DataHRenameFile, 1,
27193      PyDoc_STR("(DataHandler dh, Handle newDataRef) -> (ComponentResult _rv)")},
27194     {"DataHPlaybackHints", (PyCFunction)Qt_DataHPlaybackHints, 1,
27195      PyDoc_STR("(DataHandler dh, long flags, unsigned long minFileOffset, unsigned long maxFileOffset, long bytesPerSecond) -> (ComponentResult _rv)")},
27196     {"DataHPlaybackHints64", (PyCFunction)Qt_DataHPlaybackHints64, 1,
27197      PyDoc_STR("(DataHandler dh, long flags, wide minFileOffset, wide maxFileOffset, long bytesPerSecond) -> (ComponentResult _rv)")},
27198     {"DataHGetDataRate", (PyCFunction)Qt_DataHGetDataRate, 1,
27199      PyDoc_STR("(DataHandler dh, long flags) -> (ComponentResult _rv, long bytesPerSecond)")},
27200     {"DataHSetTimeHints", (PyCFunction)Qt_DataHSetTimeHints, 1,
27201      PyDoc_STR("(DataHandler dh, long flags, long bandwidthPriority, TimeScale scale, TimeValue minTime, TimeValue maxTime) -> (ComponentResult _rv)")},
27202     {"VDGetMaxSrcRect", (PyCFunction)Qt_VDGetMaxSrcRect, 1,
27203      PyDoc_STR("(VideoDigitizerComponent ci, short inputStd) -> (ComponentResult _rv, Rect maxSrcRect)")},
27204     {"VDGetActiveSrcRect", (PyCFunction)Qt_VDGetActiveSrcRect, 1,
27205      PyDoc_STR("(VideoDigitizerComponent ci, short inputStd) -> (ComponentResult _rv, Rect activeSrcRect)")},
27206     {"VDSetDigitizerRect", (PyCFunction)Qt_VDSetDigitizerRect, 1,
27207      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, Rect digitizerRect)")},
27208     {"VDGetDigitizerRect", (PyCFunction)Qt_VDGetDigitizerRect, 1,
27209      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, Rect digitizerRect)")},
27210     {"VDGetVBlankRect", (PyCFunction)Qt_VDGetVBlankRect, 1,
27211      PyDoc_STR("(VideoDigitizerComponent ci, short inputStd) -> (ComponentResult _rv, Rect vBlankRect)")},
27212     {"VDGetMaskPixMap", (PyCFunction)Qt_VDGetMaskPixMap, 1,
27213      PyDoc_STR("(VideoDigitizerComponent ci, PixMapHandle maskPixMap) -> (ComponentResult _rv)")},
27214     {"VDUseThisCLUT", (PyCFunction)Qt_VDUseThisCLUT, 1,
27215      PyDoc_STR("(VideoDigitizerComponent ci, CTabHandle colorTableHandle) -> (ComponentResult _rv)")},
27216     {"VDSetInputGammaValue", (PyCFunction)Qt_VDSetInputGammaValue, 1,
27217      PyDoc_STR("(VideoDigitizerComponent ci, Fixed channel1, Fixed channel2, Fixed channel3) -> (ComponentResult _rv)")},
27218     {"VDGetInputGammaValue", (PyCFunction)Qt_VDGetInputGammaValue, 1,
27219      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, Fixed channel1, Fixed channel2, Fixed channel3)")},
27220     {"VDSetBrightness", (PyCFunction)Qt_VDSetBrightness, 1,
27221      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short brightness)")},
27222     {"VDGetBrightness", (PyCFunction)Qt_VDGetBrightness, 1,
27223      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short brightness)")},
27224     {"VDSetContrast", (PyCFunction)Qt_VDSetContrast, 1,
27225      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short contrast)")},
27226     {"VDSetHue", (PyCFunction)Qt_VDSetHue, 1,
27227      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short hue)")},
27228     {"VDSetSharpness", (PyCFunction)Qt_VDSetSharpness, 1,
27229      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short sharpness)")},
27230     {"VDSetSaturation", (PyCFunction)Qt_VDSetSaturation, 1,
27231      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short saturation)")},
27232     {"VDGetContrast", (PyCFunction)Qt_VDGetContrast, 1,
27233      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short contrast)")},
27234     {"VDGetHue", (PyCFunction)Qt_VDGetHue, 1,
27235      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short hue)")},
27236     {"VDGetSharpness", (PyCFunction)Qt_VDGetSharpness, 1,
27237      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short sharpness)")},
27238     {"VDGetSaturation", (PyCFunction)Qt_VDGetSaturation, 1,
27239      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short saturation)")},
27240     {"VDGrabOneFrame", (PyCFunction)Qt_VDGrabOneFrame, 1,
27241      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv)")},
27242     {"VDGetMaxAuxBuffer", (PyCFunction)Qt_VDGetMaxAuxBuffer, 1,
27243      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, PixMapHandle pm, Rect r)")},
27244     {"VDGetCurrentFlags", (PyCFunction)Qt_VDGetCurrentFlags, 1,
27245      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, long inputCurrentFlag, long outputCurrentFlag)")},
27246     {"VDSetKeyColor", (PyCFunction)Qt_VDSetKeyColor, 1,
27247      PyDoc_STR("(VideoDigitizerComponent ci, long index) -> (ComponentResult _rv)")},
27248     {"VDGetKeyColor", (PyCFunction)Qt_VDGetKeyColor, 1,
27249      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, long index)")},
27250     {"VDAddKeyColor", (PyCFunction)Qt_VDAddKeyColor, 1,
27251      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, long index)")},
27252     {"VDGetNextKeyColor", (PyCFunction)Qt_VDGetNextKeyColor, 1,
27253      PyDoc_STR("(VideoDigitizerComponent ci, long index) -> (ComponentResult _rv)")},
27254     {"VDSetKeyColorRange", (PyCFunction)Qt_VDSetKeyColorRange, 1,
27255      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, RGBColor minRGB, RGBColor maxRGB)")},
27256     {"VDGetKeyColorRange", (PyCFunction)Qt_VDGetKeyColorRange, 1,
27257      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, RGBColor minRGB, RGBColor maxRGB)")},
27258     {"VDSetInputColorSpaceMode", (PyCFunction)Qt_VDSetInputColorSpaceMode, 1,
27259      PyDoc_STR("(VideoDigitizerComponent ci, short colorSpaceMode) -> (ComponentResult _rv)")},
27260     {"VDGetInputColorSpaceMode", (PyCFunction)Qt_VDGetInputColorSpaceMode, 1,
27261      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, short colorSpaceMode)")},
27262     {"VDSetClipState", (PyCFunction)Qt_VDSetClipState, 1,
27263      PyDoc_STR("(VideoDigitizerComponent ci, short clipEnable) -> (ComponentResult _rv)")},
27264     {"VDGetClipState", (PyCFunction)Qt_VDGetClipState, 1,
27265      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, short clipEnable)")},
27266     {"VDSetClipRgn", (PyCFunction)Qt_VDSetClipRgn, 1,
27267      PyDoc_STR("(VideoDigitizerComponent ci, RgnHandle clipRegion) -> (ComponentResult _rv)")},
27268     {"VDClearClipRgn", (PyCFunction)Qt_VDClearClipRgn, 1,
27269      PyDoc_STR("(VideoDigitizerComponent ci, RgnHandle clipRegion) -> (ComponentResult _rv)")},
27270     {"VDGetCLUTInUse", (PyCFunction)Qt_VDGetCLUTInUse, 1,
27271      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, CTabHandle colorTableHandle)")},
27272     {"VDSetPLLFilterType", (PyCFunction)Qt_VDSetPLLFilterType, 1,
27273      PyDoc_STR("(VideoDigitizerComponent ci, short pllType) -> (ComponentResult _rv)")},
27274     {"VDGetPLLFilterType", (PyCFunction)Qt_VDGetPLLFilterType, 1,
27275      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, short pllType)")},
27276     {"VDGetMaskandValue", (PyCFunction)Qt_VDGetMaskandValue, 1,
27277      PyDoc_STR("(VideoDigitizerComponent ci, unsigned short blendLevel) -> (ComponentResult _rv, long mask, long value)")},
27278     {"VDSetMasterBlendLevel", (PyCFunction)Qt_VDSetMasterBlendLevel, 1,
27279      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short blendLevel)")},
27280     {"VDSetPlayThruOnOff", (PyCFunction)Qt_VDSetPlayThruOnOff, 1,
27281      PyDoc_STR("(VideoDigitizerComponent ci, short state) -> (ComponentResult _rv)")},
27282     {"VDSetFieldPreference", (PyCFunction)Qt_VDSetFieldPreference, 1,
27283      PyDoc_STR("(VideoDigitizerComponent ci, short fieldFlag) -> (ComponentResult _rv)")},
27284     {"VDGetFieldPreference", (PyCFunction)Qt_VDGetFieldPreference, 1,
27285      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, short fieldFlag)")},
27286     {"VDPreflightGlobalRect", (PyCFunction)Qt_VDPreflightGlobalRect, 1,
27287      PyDoc_STR("(VideoDigitizerComponent ci, GrafPtr theWindow) -> (ComponentResult _rv, Rect globalRect)")},
27288     {"VDSetPlayThruGlobalRect", (PyCFunction)Qt_VDSetPlayThruGlobalRect, 1,
27289      PyDoc_STR("(VideoDigitizerComponent ci, GrafPtr theWindow) -> (ComponentResult _rv, Rect globalRect)")},
27290     {"VDSetBlackLevelValue", (PyCFunction)Qt_VDSetBlackLevelValue, 1,
27291      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short blackLevel)")},
27292     {"VDGetBlackLevelValue", (PyCFunction)Qt_VDGetBlackLevelValue, 1,
27293      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short blackLevel)")},
27294     {"VDSetWhiteLevelValue", (PyCFunction)Qt_VDSetWhiteLevelValue, 1,
27295      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short whiteLevel)")},
27296     {"VDGetWhiteLevelValue", (PyCFunction)Qt_VDGetWhiteLevelValue, 1,
27297      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short whiteLevel)")},
27298     {"VDGetVideoDefaults", (PyCFunction)Qt_VDGetVideoDefaults, 1,
27299      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, unsigned short blackLevel, unsigned short whiteLevel, unsigned short brightness, unsigned short hue, unsigned short saturation, unsigned short contrast, unsigned short sharpness)")},
27300     {"VDGetNumberOfInputs", (PyCFunction)Qt_VDGetNumberOfInputs, 1,
27301      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, short inputs)")},
27302     {"VDGetInputFormat", (PyCFunction)Qt_VDGetInputFormat, 1,
27303      PyDoc_STR("(VideoDigitizerComponent ci, short input) -> (ComponentResult _rv, short format)")},
27304     {"VDSetInput", (PyCFunction)Qt_VDSetInput, 1,
27305      PyDoc_STR("(VideoDigitizerComponent ci, short input) -> (ComponentResult _rv)")},
27306     {"VDGetInput", (PyCFunction)Qt_VDGetInput, 1,
27307      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, short input)")},
27308     {"VDSetInputStandard", (PyCFunction)Qt_VDSetInputStandard, 1,
27309      PyDoc_STR("(VideoDigitizerComponent ci, short inputStandard) -> (ComponentResult _rv)")},
27310     {"VDSetupBuffers", (PyCFunction)Qt_VDSetupBuffers, 1,
27311      PyDoc_STR("(VideoDigitizerComponent ci, VdigBufferRecListHandle bufferList) -> (ComponentResult _rv)")},
27312     {"VDGrabOneFrameAsync", (PyCFunction)Qt_VDGrabOneFrameAsync, 1,
27313      PyDoc_STR("(VideoDigitizerComponent ci, short buffer) -> (ComponentResult _rv)")},
27314     {"VDDone", (PyCFunction)Qt_VDDone, 1,
27315      PyDoc_STR("(VideoDigitizerComponent ci, short buffer) -> (ComponentResult _rv)")},
27316     {"VDSetCompression", (PyCFunction)Qt_VDSetCompression, 1,
27317      PyDoc_STR("(VideoDigitizerComponent ci, OSType compressType, short depth, CodecQ spatialQuality, CodecQ temporalQuality, long keyFrameRate) -> (ComponentResult _rv, Rect bounds)")},
27318     {"VDCompressOneFrameAsync", (PyCFunction)Qt_VDCompressOneFrameAsync, 1,
27319      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv)")},
27320     {"VDGetImageDescription", (PyCFunction)Qt_VDGetImageDescription, 1,
27321      PyDoc_STR("(VideoDigitizerComponent ci, ImageDescriptionHandle desc) -> (ComponentResult _rv)")},
27322     {"VDResetCompressSequence", (PyCFunction)Qt_VDResetCompressSequence, 1,
27323      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv)")},
27324     {"VDSetCompressionOnOff", (PyCFunction)Qt_VDSetCompressionOnOff, 1,
27325      PyDoc_STR("(VideoDigitizerComponent ci, Boolean state) -> (ComponentResult _rv)")},
27326     {"VDGetCompressionTypes", (PyCFunction)Qt_VDGetCompressionTypes, 1,
27327      PyDoc_STR("(VideoDigitizerComponent ci, VDCompressionListHandle h) -> (ComponentResult _rv)")},
27328     {"VDSetTimeBase", (PyCFunction)Qt_VDSetTimeBase, 1,
27329      PyDoc_STR("(VideoDigitizerComponent ci, TimeBase t) -> (ComponentResult _rv)")},
27330     {"VDSetFrameRate", (PyCFunction)Qt_VDSetFrameRate, 1,
27331      PyDoc_STR("(VideoDigitizerComponent ci, Fixed framesPerSecond) -> (ComponentResult _rv)")},
27332     {"VDGetDataRate", (PyCFunction)Qt_VDGetDataRate, 1,
27333      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, long milliSecPerFrame, Fixed framesPerSecond, long bytesPerSecond)")},
27334     {"VDGetSoundInputDriver", (PyCFunction)Qt_VDGetSoundInputDriver, 1,
27335      PyDoc_STR("(VideoDigitizerComponent ci, Str255 soundDriverName) -> (ComponentResult _rv)")},
27336     {"VDGetDMADepths", (PyCFunction)Qt_VDGetDMADepths, 1,
27337      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, long depthArray, long preferredDepth)")},
27338     {"VDGetPreferredTimeScale", (PyCFunction)Qt_VDGetPreferredTimeScale, 1,
27339      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, TimeScale preferred)")},
27340     {"VDReleaseAsyncBuffers", (PyCFunction)Qt_VDReleaseAsyncBuffers, 1,
27341      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv)")},
27342     {"VDSetDataRate", (PyCFunction)Qt_VDSetDataRate, 1,
27343      PyDoc_STR("(VideoDigitizerComponent ci, long bytesPerSecond) -> (ComponentResult _rv)")},
27344     {"VDGetTimeCode", (PyCFunction)Qt_VDGetTimeCode, 1,
27345      PyDoc_STR("(VideoDigitizerComponent ci, void * timeCodeFormat, void * timeCodeTime) -> (ComponentResult _rv, TimeRecord atTime)")},
27346     {"VDUseSafeBuffers", (PyCFunction)Qt_VDUseSafeBuffers, 1,
27347      PyDoc_STR("(VideoDigitizerComponent ci, Boolean useSafeBuffers) -> (ComponentResult _rv)")},
27348     {"VDGetSoundInputSource", (PyCFunction)Qt_VDGetSoundInputSource, 1,
27349      PyDoc_STR("(VideoDigitizerComponent ci, long videoInput) -> (ComponentResult _rv, long soundInput)")},
27350     {"VDGetCompressionTime", (PyCFunction)Qt_VDGetCompressionTime, 1,
27351      PyDoc_STR("(VideoDigitizerComponent ci, OSType compressionType, short depth) -> (ComponentResult _rv, Rect srcRect, CodecQ spatialQuality, CodecQ temporalQuality, unsigned long compressTime)")},
27352     {"VDSetPreferredPacketSize", (PyCFunction)Qt_VDSetPreferredPacketSize, 1,
27353      PyDoc_STR("(VideoDigitizerComponent ci, long preferredPacketSizeInBytes) -> (ComponentResult _rv)")},
27354     {"VDSetPreferredImageDimensions", (PyCFunction)Qt_VDSetPreferredImageDimensions, 1,
27355      PyDoc_STR("(VideoDigitizerComponent ci, long width, long height) -> (ComponentResult _rv)")},
27356     {"VDGetPreferredImageDimensions", (PyCFunction)Qt_VDGetPreferredImageDimensions, 1,
27357      PyDoc_STR("(VideoDigitizerComponent ci) -> (ComponentResult _rv, long width, long height)")},
27358     {"VDGetInputName", (PyCFunction)Qt_VDGetInputName, 1,
27359      PyDoc_STR("(VideoDigitizerComponent ci, long videoInput, Str255 name) -> (ComponentResult _rv)")},
27360     {"VDSetDestinationPort", (PyCFunction)Qt_VDSetDestinationPort, 1,
27361      PyDoc_STR("(VideoDigitizerComponent ci, CGrafPtr destPort) -> (ComponentResult _rv)")},
27362     {"VDGetDeviceNameAndFlags", (PyCFunction)Qt_VDGetDeviceNameAndFlags, 1,
27363      PyDoc_STR("(VideoDigitizerComponent ci, Str255 outName) -> (ComponentResult _rv, UInt32 outNameFlags)")},
27364     {"VDCaptureStateChanging", (PyCFunction)Qt_VDCaptureStateChanging, 1,
27365      PyDoc_STR("(VideoDigitizerComponent ci, UInt32 inStateFlags) -> (ComponentResult _rv)")},
27366     {"XMLParseGetDetailedParseError", (PyCFunction)Qt_XMLParseGetDetailedParseError, 1,
27367      PyDoc_STR("(ComponentInstance aParser, StringPtr errDesc) -> (ComponentResult _rv, long errorLine)")},
27368     {"XMLParseAddElement", (PyCFunction)Qt_XMLParseAddElement, 1,
27369      PyDoc_STR("(ComponentInstance aParser, UInt32 nameSpaceID, long elementFlags) -> (ComponentResult _rv, char elementName, UInt32 elementID)")},
27370     {"XMLParseAddAttribute", (PyCFunction)Qt_XMLParseAddAttribute, 1,
27371      PyDoc_STR("(ComponentInstance aParser, UInt32 elementID, UInt32 nameSpaceID) -> (ComponentResult _rv, char attributeName, UInt32 attributeID)")},
27372     {"XMLParseAddMultipleAttributes", (PyCFunction)Qt_XMLParseAddMultipleAttributes, 1,
27373      PyDoc_STR("(ComponentInstance aParser, UInt32 elementID) -> (ComponentResult _rv, UInt32 nameSpaceIDs, char attributeNames, UInt32 attributeIDs)")},
27374     {"XMLParseAddAttributeAndValue", (PyCFunction)Qt_XMLParseAddAttributeAndValue, 1,
27375      PyDoc_STR("(ComponentInstance aParser, UInt32 elementID, UInt32 nameSpaceID, UInt32 attributeValueKind, void * attributeValueKindInfo) -> (ComponentResult _rv, char attributeName, UInt32 attributeID)")},
27376     {"XMLParseAddAttributeValueKind", (PyCFunction)Qt_XMLParseAddAttributeValueKind, 1,
27377      PyDoc_STR("(ComponentInstance aParser, UInt32 elementID, UInt32 attributeID, UInt32 attributeValueKind, void * attributeValueKindInfo) -> (ComponentResult _rv)")},
27378     {"XMLParseAddNameSpace", (PyCFunction)Qt_XMLParseAddNameSpace, 1,
27379      PyDoc_STR("(ComponentInstance aParser) -> (ComponentResult _rv, char nameSpaceURL, UInt32 nameSpaceID)")},
27380     {"XMLParseSetOffsetAndLimit", (PyCFunction)Qt_XMLParseSetOffsetAndLimit, 1,
27381      PyDoc_STR("(ComponentInstance aParser, UInt32 offset, UInt32 limit) -> (ComponentResult _rv)")},
27382     {"XMLParseSetEventParseRefCon", (PyCFunction)Qt_XMLParseSetEventParseRefCon, 1,
27383      PyDoc_STR("(ComponentInstance aParser, long refcon) -> (ComponentResult _rv)")},
27384     {"SGInitialize", (PyCFunction)Qt_SGInitialize, 1,
27385      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv)")},
27386     {"SGSetDataOutput", (PyCFunction)Qt_SGSetDataOutput, 1,
27387      PyDoc_STR("(SeqGrabComponent s, FSSpec movieFile, long whereFlags) -> (ComponentResult _rv)")},
27388     {"SGGetDataOutput", (PyCFunction)Qt_SGGetDataOutput, 1,
27389      PyDoc_STR("(SeqGrabComponent s, FSSpec movieFile) -> (ComponentResult _rv, long whereFlags)")},
27390     {"SGSetGWorld", (PyCFunction)Qt_SGSetGWorld, 1,
27391      PyDoc_STR("(SeqGrabComponent s, CGrafPtr gp, GDHandle gd) -> (ComponentResult _rv)")},
27392     {"SGGetGWorld", (PyCFunction)Qt_SGGetGWorld, 1,
27393      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, CGrafPtr gp, GDHandle gd)")},
27394     {"SGNewChannel", (PyCFunction)Qt_SGNewChannel, 1,
27395      PyDoc_STR("(SeqGrabComponent s, OSType channelType) -> (ComponentResult _rv, SGChannel ref)")},
27396     {"SGDisposeChannel", (PyCFunction)Qt_SGDisposeChannel, 1,
27397      PyDoc_STR("(SeqGrabComponent s, SGChannel c) -> (ComponentResult _rv)")},
27398     {"SGStartPreview", (PyCFunction)Qt_SGStartPreview, 1,
27399      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv)")},
27400     {"SGStartRecord", (PyCFunction)Qt_SGStartRecord, 1,
27401      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv)")},
27402     {"SGIdle", (PyCFunction)Qt_SGIdle, 1,
27403      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv)")},
27404     {"SGStop", (PyCFunction)Qt_SGStop, 1,
27405      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv)")},
27406     {"SGPause", (PyCFunction)Qt_SGPause, 1,
27407      PyDoc_STR("(SeqGrabComponent s, Boolean pause) -> (ComponentResult _rv)")},
27408     {"SGPrepare", (PyCFunction)Qt_SGPrepare, 1,
27409      PyDoc_STR("(SeqGrabComponent s, Boolean prepareForPreview, Boolean prepareForRecord) -> (ComponentResult _rv)")},
27410     {"SGRelease", (PyCFunction)Qt_SGRelease, 1,
27411      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv)")},
27412     {"SGGetMovie", (PyCFunction)Qt_SGGetMovie, 1,
27413      PyDoc_STR("(SeqGrabComponent s) -> (Movie _rv)")},
27414     {"SGSetMaximumRecordTime", (PyCFunction)Qt_SGSetMaximumRecordTime, 1,
27415      PyDoc_STR("(SeqGrabComponent s, unsigned long ticks) -> (ComponentResult _rv)")},
27416     {"SGGetMaximumRecordTime", (PyCFunction)Qt_SGGetMaximumRecordTime, 1,
27417      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, unsigned long ticks)")},
27418     {"SGGetStorageSpaceRemaining", (PyCFunction)Qt_SGGetStorageSpaceRemaining, 1,
27419      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, unsigned long bytes)")},
27420     {"SGGetTimeRemaining", (PyCFunction)Qt_SGGetTimeRemaining, 1,
27421      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, long ticksLeft)")},
27422     {"SGGrabPict", (PyCFunction)Qt_SGGrabPict, 1,
27423      PyDoc_STR("(SeqGrabComponent s, Rect bounds, short offscreenDepth, long grabPictFlags) -> (ComponentResult _rv, PicHandle p)")},
27424     {"SGGetLastMovieResID", (PyCFunction)Qt_SGGetLastMovieResID, 1,
27425      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, short resID)")},
27426     {"SGSetFlags", (PyCFunction)Qt_SGSetFlags, 1,
27427      PyDoc_STR("(SeqGrabComponent s, long sgFlags) -> (ComponentResult _rv)")},
27428     {"SGGetFlags", (PyCFunction)Qt_SGGetFlags, 1,
27429      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, long sgFlags)")},
27430     {"SGNewChannelFromComponent", (PyCFunction)Qt_SGNewChannelFromComponent, 1,
27431      PyDoc_STR("(SeqGrabComponent s, Component sgChannelComponent) -> (ComponentResult _rv, SGChannel newChannel)")},
27432     {"SGSetSettings", (PyCFunction)Qt_SGSetSettings, 1,
27433      PyDoc_STR("(SeqGrabComponent s, UserData ud, long flags) -> (ComponentResult _rv)")},
27434     {"SGGetSettings", (PyCFunction)Qt_SGGetSettings, 1,
27435      PyDoc_STR("(SeqGrabComponent s, long flags) -> (ComponentResult _rv, UserData ud)")},
27436     {"SGGetIndChannel", (PyCFunction)Qt_SGGetIndChannel, 1,
27437      PyDoc_STR("(SeqGrabComponent s, short index) -> (ComponentResult _rv, SGChannel ref, OSType chanType)")},
27438     {"SGUpdate", (PyCFunction)Qt_SGUpdate, 1,
27439      PyDoc_STR("(SeqGrabComponent s, RgnHandle updateRgn) -> (ComponentResult _rv)")},
27440     {"SGGetPause", (PyCFunction)Qt_SGGetPause, 1,
27441      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, Boolean paused)")},
27442     {"SGSetChannelSettings", (PyCFunction)Qt_SGSetChannelSettings, 1,
27443      PyDoc_STR("(SeqGrabComponent s, SGChannel c, UserData ud, long flags) -> (ComponentResult _rv)")},
27444     {"SGGetChannelSettings", (PyCFunction)Qt_SGGetChannelSettings, 1,
27445      PyDoc_STR("(SeqGrabComponent s, SGChannel c, long flags) -> (ComponentResult _rv, UserData ud)")},
27446     {"SGGetMode", (PyCFunction)Qt_SGGetMode, 1,
27447      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, Boolean previewMode, Boolean recordMode)")},
27448     {"SGSetDataRef", (PyCFunction)Qt_SGSetDataRef, 1,
27449      PyDoc_STR("(SeqGrabComponent s, Handle dataRef, OSType dataRefType, long whereFlags) -> (ComponentResult _rv)")},
27450     {"SGGetDataRef", (PyCFunction)Qt_SGGetDataRef, 1,
27451      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, Handle dataRef, OSType dataRefType, long whereFlags)")},
27452     {"SGNewOutput", (PyCFunction)Qt_SGNewOutput, 1,
27453      PyDoc_STR("(SeqGrabComponent s, Handle dataRef, OSType dataRefType, long whereFlags) -> (ComponentResult _rv, SGOutput sgOut)")},
27454     {"SGDisposeOutput", (PyCFunction)Qt_SGDisposeOutput, 1,
27455      PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut) -> (ComponentResult _rv)")},
27456     {"SGSetOutputFlags", (PyCFunction)Qt_SGSetOutputFlags, 1,
27457      PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut, long whereFlags) -> (ComponentResult _rv)")},
27458     {"SGSetChannelOutput", (PyCFunction)Qt_SGSetChannelOutput, 1,
27459      PyDoc_STR("(SeqGrabComponent s, SGChannel c, SGOutput sgOut) -> (ComponentResult _rv)")},
27460     {"SGGetDataOutputStorageSpaceRemaining", (PyCFunction)Qt_SGGetDataOutputStorageSpaceRemaining, 1,
27461      PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut) -> (ComponentResult _rv, unsigned long space)")},
27462     {"SGHandleUpdateEvent", (PyCFunction)Qt_SGHandleUpdateEvent, 1,
27463      PyDoc_STR("(SeqGrabComponent s, EventRecord event) -> (ComponentResult _rv, Boolean handled)")},
27464     {"SGSetOutputNextOutput", (PyCFunction)Qt_SGSetOutputNextOutput, 1,
27465      PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut, SGOutput nextOut) -> (ComponentResult _rv)")},
27466     {"SGGetOutputNextOutput", (PyCFunction)Qt_SGGetOutputNextOutput, 1,
27467      PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut) -> (ComponentResult _rv, SGOutput nextOut)")},
27468     {"SGSetOutputMaximumOffset", (PyCFunction)Qt_SGSetOutputMaximumOffset, 1,
27469      PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut, wide maxOffset) -> (ComponentResult _rv)")},
27470     {"SGGetOutputMaximumOffset", (PyCFunction)Qt_SGGetOutputMaximumOffset, 1,
27471      PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut) -> (ComponentResult _rv, wide maxOffset)")},
27472     {"SGGetOutputDataReference", (PyCFunction)Qt_SGGetOutputDataReference, 1,
27473      PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut) -> (ComponentResult _rv, Handle dataRef, OSType dataRefType)")},
27474     {"SGWriteExtendedMovieData", (PyCFunction)Qt_SGWriteExtendedMovieData, 1,
27475      PyDoc_STR("(SeqGrabComponent s, SGChannel c, Ptr p, long len) -> (ComponentResult _rv, wide offset, SGOutput sgOut)")},
27476     {"SGGetStorageSpaceRemaining64", (PyCFunction)Qt_SGGetStorageSpaceRemaining64, 1,
27477      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, wide bytes)")},
27478     {"SGGetDataOutputStorageSpaceRemaining64", (PyCFunction)Qt_SGGetDataOutputStorageSpaceRemaining64, 1,
27479      PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut) -> (ComponentResult _rv, wide space)")},
27480     {"SGWriteMovieData", (PyCFunction)Qt_SGWriteMovieData, 1,
27481      PyDoc_STR("(SeqGrabComponent s, SGChannel c, Ptr p, long len) -> (ComponentResult _rv, long offset)")},
27482     {"SGGetTimeBase", (PyCFunction)Qt_SGGetTimeBase, 1,
27483      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, TimeBase tb)")},
27484     {"SGAddMovieData", (PyCFunction)Qt_SGAddMovieData, 1,
27485      PyDoc_STR("(SeqGrabComponent s, SGChannel c, Ptr p, long len, long chRefCon, TimeValue time, short writeType) -> (ComponentResult _rv, long offset)")},
27486     {"SGChangedSource", (PyCFunction)Qt_SGChangedSource, 1,
27487      PyDoc_STR("(SeqGrabComponent s, SGChannel c) -> (ComponentResult _rv)")},
27488     {"SGAddExtendedMovieData", (PyCFunction)Qt_SGAddExtendedMovieData, 1,
27489      PyDoc_STR("(SeqGrabComponent s, SGChannel c, Ptr p, long len, long chRefCon, TimeValue time, short writeType) -> (ComponentResult _rv, wide offset, SGOutput whichOutput)")},
27490     {"SGAddOutputDataRefToMedia", (PyCFunction)Qt_SGAddOutputDataRefToMedia, 1,
27491      PyDoc_STR("(SeqGrabComponent s, SGOutput sgOut, Media theMedia, SampleDescriptionHandle desc) -> (ComponentResult _rv)")},
27492     {"SGSetSettingsSummary", (PyCFunction)Qt_SGSetSettingsSummary, 1,
27493      PyDoc_STR("(SeqGrabComponent s, Handle summaryText) -> (ComponentResult _rv)")},
27494     {"SGSetChannelUsage", (PyCFunction)Qt_SGSetChannelUsage, 1,
27495      PyDoc_STR("(SGChannel c, long usage) -> (ComponentResult _rv)")},
27496     {"SGGetChannelUsage", (PyCFunction)Qt_SGGetChannelUsage, 1,
27497      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long usage)")},
27498     {"SGSetChannelBounds", (PyCFunction)Qt_SGSetChannelBounds, 1,
27499      PyDoc_STR("(SGChannel c, Rect bounds) -> (ComponentResult _rv)")},
27500     {"SGGetChannelBounds", (PyCFunction)Qt_SGGetChannelBounds, 1,
27501      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Rect bounds)")},
27502     {"SGSetChannelVolume", (PyCFunction)Qt_SGSetChannelVolume, 1,
27503      PyDoc_STR("(SGChannel c, short volume) -> (ComponentResult _rv)")},
27504     {"SGGetChannelVolume", (PyCFunction)Qt_SGGetChannelVolume, 1,
27505      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, short volume)")},
27506     {"SGGetChannelInfo", (PyCFunction)Qt_SGGetChannelInfo, 1,
27507      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long channelInfo)")},
27508     {"SGSetChannelPlayFlags", (PyCFunction)Qt_SGSetChannelPlayFlags, 1,
27509      PyDoc_STR("(SGChannel c, long playFlags) -> (ComponentResult _rv)")},
27510     {"SGGetChannelPlayFlags", (PyCFunction)Qt_SGGetChannelPlayFlags, 1,
27511      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long playFlags)")},
27512     {"SGSetChannelMaxFrames", (PyCFunction)Qt_SGSetChannelMaxFrames, 1,
27513      PyDoc_STR("(SGChannel c, long frameCount) -> (ComponentResult _rv)")},
27514     {"SGGetChannelMaxFrames", (PyCFunction)Qt_SGGetChannelMaxFrames, 1,
27515      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long frameCount)")},
27516     {"SGSetChannelRefCon", (PyCFunction)Qt_SGSetChannelRefCon, 1,
27517      PyDoc_STR("(SGChannel c, long refCon) -> (ComponentResult _rv)")},
27518     {"SGSetChannelClip", (PyCFunction)Qt_SGSetChannelClip, 1,
27519      PyDoc_STR("(SGChannel c, RgnHandle theClip) -> (ComponentResult _rv)")},
27520     {"SGGetChannelClip", (PyCFunction)Qt_SGGetChannelClip, 1,
27521      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, RgnHandle theClip)")},
27522     {"SGGetChannelSampleDescription", (PyCFunction)Qt_SGGetChannelSampleDescription, 1,
27523      PyDoc_STR("(SGChannel c, Handle sampleDesc) -> (ComponentResult _rv)")},
27524     {"SGSetChannelDevice", (PyCFunction)Qt_SGSetChannelDevice, 1,
27525      PyDoc_STR("(SGChannel c, StringPtr name) -> (ComponentResult _rv)")},
27526     {"SGGetChannelTimeScale", (PyCFunction)Qt_SGGetChannelTimeScale, 1,
27527      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, TimeScale scale)")},
27528     {"SGChannelPutPicture", (PyCFunction)Qt_SGChannelPutPicture, 1,
27529      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv)")},
27530     {"SGChannelSetRequestedDataRate", (PyCFunction)Qt_SGChannelSetRequestedDataRate, 1,
27531      PyDoc_STR("(SGChannel c, long bytesPerSecond) -> (ComponentResult _rv)")},
27532     {"SGChannelGetRequestedDataRate", (PyCFunction)Qt_SGChannelGetRequestedDataRate, 1,
27533      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long bytesPerSecond)")},
27534     {"SGChannelSetDataSourceName", (PyCFunction)Qt_SGChannelSetDataSourceName, 1,
27535      PyDoc_STR("(SGChannel c, Str255 name, ScriptCode scriptTag) -> (ComponentResult _rv)")},
27536     {"SGChannelGetDataSourceName", (PyCFunction)Qt_SGChannelGetDataSourceName, 1,
27537      PyDoc_STR("(SGChannel c, Str255 name) -> (ComponentResult _rv, ScriptCode scriptTag)")},
27538     {"SGChannelSetCodecSettings", (PyCFunction)Qt_SGChannelSetCodecSettings, 1,
27539      PyDoc_STR("(SGChannel c, Handle settings) -> (ComponentResult _rv)")},
27540     {"SGChannelGetCodecSettings", (PyCFunction)Qt_SGChannelGetCodecSettings, 1,
27541      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Handle settings)")},
27542     {"SGGetChannelTimeBase", (PyCFunction)Qt_SGGetChannelTimeBase, 1,
27543      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, TimeBase tb)")},
27544     {"SGGetChannelRefCon", (PyCFunction)Qt_SGGetChannelRefCon, 1,
27545      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long refCon)")},
27546     {"SGGetChannelDeviceAndInputNames", (PyCFunction)Qt_SGGetChannelDeviceAndInputNames, 1,
27547      PyDoc_STR("(SGChannel c, Str255 outDeviceName, Str255 outInputName) -> (ComponentResult _rv, short outInputNumber)")},
27548     {"SGSetChannelDeviceInput", (PyCFunction)Qt_SGSetChannelDeviceInput, 1,
27549      PyDoc_STR("(SGChannel c, short inInputNumber) -> (ComponentResult _rv)")},
27550     {"SGSetChannelSettingsStateChanging", (PyCFunction)Qt_SGSetChannelSettingsStateChanging, 1,
27551      PyDoc_STR("(SGChannel c, UInt32 inFlags) -> (ComponentResult _rv)")},
27552     {"SGInitChannel", (PyCFunction)Qt_SGInitChannel, 1,
27553      PyDoc_STR("(SGChannel c, SeqGrabComponent owner) -> (ComponentResult _rv)")},
27554     {"SGWriteSamples", (PyCFunction)Qt_SGWriteSamples, 1,
27555      PyDoc_STR("(SGChannel c, Movie m, AliasHandle theFile) -> (ComponentResult _rv)")},
27556     {"SGGetDataRate", (PyCFunction)Qt_SGGetDataRate, 1,
27557      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long bytesPerSecond)")},
27558     {"SGAlignChannelRect", (PyCFunction)Qt_SGAlignChannelRect, 1,
27559      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Rect r)")},
27560     {"SGPanelGetDitl", (PyCFunction)Qt_SGPanelGetDitl, 1,
27561      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, Handle ditl)")},
27562     {"SGPanelGetTitle", (PyCFunction)Qt_SGPanelGetTitle, 1,
27563      PyDoc_STR("(SeqGrabComponent s, Str255 title) -> (ComponentResult _rv)")},
27564     {"SGPanelCanRun", (PyCFunction)Qt_SGPanelCanRun, 1,
27565      PyDoc_STR("(SeqGrabComponent s, SGChannel c) -> (ComponentResult _rv)")},
27566     {"SGPanelInstall", (PyCFunction)Qt_SGPanelInstall, 1,
27567      PyDoc_STR("(SeqGrabComponent s, SGChannel c, DialogPtr d, short itemOffset) -> (ComponentResult _rv)")},
27568     {"SGPanelEvent", (PyCFunction)Qt_SGPanelEvent, 1,
27569      PyDoc_STR("(SeqGrabComponent s, SGChannel c, DialogPtr d, short itemOffset, EventRecord theEvent) -> (ComponentResult _rv, short itemHit, Boolean handled)")},
27570     {"SGPanelItem", (PyCFunction)Qt_SGPanelItem, 1,
27571      PyDoc_STR("(SeqGrabComponent s, SGChannel c, DialogPtr d, short itemOffset, short itemNum) -> (ComponentResult _rv)")},
27572     {"SGPanelRemove", (PyCFunction)Qt_SGPanelRemove, 1,
27573      PyDoc_STR("(SeqGrabComponent s, SGChannel c, DialogPtr d, short itemOffset) -> (ComponentResult _rv)")},
27574     {"SGPanelSetGrabber", (PyCFunction)Qt_SGPanelSetGrabber, 1,
27575      PyDoc_STR("(SeqGrabComponent s, SeqGrabComponent sg) -> (ComponentResult _rv)")},
27576     {"SGPanelSetResFile", (PyCFunction)Qt_SGPanelSetResFile, 1,
27577      PyDoc_STR("(SeqGrabComponent s, short resRef) -> (ComponentResult _rv)")},
27578     {"SGPanelGetSettings", (PyCFunction)Qt_SGPanelGetSettings, 1,
27579      PyDoc_STR("(SeqGrabComponent s, SGChannel c, long flags) -> (ComponentResult _rv, UserData ud)")},
27580     {"SGPanelSetSettings", (PyCFunction)Qt_SGPanelSetSettings, 1,
27581      PyDoc_STR("(SeqGrabComponent s, SGChannel c, UserData ud, long flags) -> (ComponentResult _rv)")},
27582     {"SGPanelValidateInput", (PyCFunction)Qt_SGPanelValidateInput, 1,
27583      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, Boolean ok)")},
27584     {"SGPanelGetDITLForSize", (PyCFunction)Qt_SGPanelGetDITLForSize, 1,
27585      PyDoc_STR("(SeqGrabComponent s) -> (ComponentResult _rv, Handle ditl, Point requestedSize)")},
27586     {"SGGetSrcVideoBounds", (PyCFunction)Qt_SGGetSrcVideoBounds, 1,
27587      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Rect r)")},
27588     {"SGSetVideoRect", (PyCFunction)Qt_SGSetVideoRect, 1,
27589      PyDoc_STR("(SGChannel c, Rect r) -> (ComponentResult _rv)")},
27590     {"SGGetVideoRect", (PyCFunction)Qt_SGGetVideoRect, 1,
27591      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Rect r)")},
27592     {"SGGetVideoCompressorType", (PyCFunction)Qt_SGGetVideoCompressorType, 1,
27593      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, OSType compressorType)")},
27594     {"SGSetVideoCompressorType", (PyCFunction)Qt_SGSetVideoCompressorType, 1,
27595      PyDoc_STR("(SGChannel c, OSType compressorType) -> (ComponentResult _rv)")},
27596     {"SGSetVideoCompressor", (PyCFunction)Qt_SGSetVideoCompressor, 1,
27597      PyDoc_STR("(SGChannel c, short depth, CompressorComponent compressor, CodecQ spatialQuality, CodecQ temporalQuality, long keyFrameRate) -> (ComponentResult _rv)")},
27598     {"SGGetVideoCompressor", (PyCFunction)Qt_SGGetVideoCompressor, 1,
27599      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, short depth, CompressorComponent compressor, CodecQ spatialQuality, CodecQ temporalQuality, long keyFrameRate)")},
27600     {"SGGetVideoDigitizerComponent", (PyCFunction)Qt_SGGetVideoDigitizerComponent, 1,
27601      PyDoc_STR("(SGChannel c) -> (ComponentInstance _rv)")},
27602     {"SGSetVideoDigitizerComponent", (PyCFunction)Qt_SGSetVideoDigitizerComponent, 1,
27603      PyDoc_STR("(SGChannel c, ComponentInstance vdig) -> (ComponentResult _rv)")},
27604     {"SGVideoDigitizerChanged", (PyCFunction)Qt_SGVideoDigitizerChanged, 1,
27605      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv)")},
27606     {"SGGrabFrame", (PyCFunction)Qt_SGGrabFrame, 1,
27607      PyDoc_STR("(SGChannel c, short bufferNum) -> (ComponentResult _rv)")},
27608     {"SGGrabFrameComplete", (PyCFunction)Qt_SGGrabFrameComplete, 1,
27609      PyDoc_STR("(SGChannel c, short bufferNum) -> (ComponentResult _rv, Boolean done)")},
27610     {"SGCompressFrame", (PyCFunction)Qt_SGCompressFrame, 1,
27611      PyDoc_STR("(SGChannel c, short bufferNum) -> (ComponentResult _rv)")},
27612     {"SGSetCompressBuffer", (PyCFunction)Qt_SGSetCompressBuffer, 1,
27613      PyDoc_STR("(SGChannel c, short depth, Rect compressSize) -> (ComponentResult _rv)")},
27614     {"SGGetCompressBuffer", (PyCFunction)Qt_SGGetCompressBuffer, 1,
27615      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, short depth, Rect compressSize)")},
27616     {"SGGetBufferInfo", (PyCFunction)Qt_SGGetBufferInfo, 1,
27617      PyDoc_STR("(SGChannel c, short bufferNum) -> (ComponentResult _rv, PixMapHandle bufferPM, Rect bufferRect, GWorldPtr compressBuffer, Rect compressBufferRect)")},
27618     {"SGSetUseScreenBuffer", (PyCFunction)Qt_SGSetUseScreenBuffer, 1,
27619      PyDoc_STR("(SGChannel c, Boolean useScreenBuffer) -> (ComponentResult _rv)")},
27620     {"SGGetUseScreenBuffer", (PyCFunction)Qt_SGGetUseScreenBuffer, 1,
27621      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Boolean useScreenBuffer)")},
27622     {"SGSetFrameRate", (PyCFunction)Qt_SGSetFrameRate, 1,
27623      PyDoc_STR("(SGChannel c, Fixed frameRate) -> (ComponentResult _rv)")},
27624     {"SGGetFrameRate", (PyCFunction)Qt_SGGetFrameRate, 1,
27625      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Fixed frameRate)")},
27626     {"SGSetPreferredPacketSize", (PyCFunction)Qt_SGSetPreferredPacketSize, 1,
27627      PyDoc_STR("(SGChannel c, long preferredPacketSizeInBytes) -> (ComponentResult _rv)")},
27628     {"SGGetPreferredPacketSize", (PyCFunction)Qt_SGGetPreferredPacketSize, 1,
27629      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, long preferredPacketSizeInBytes)")},
27630     {"SGSetUserVideoCompressorList", (PyCFunction)Qt_SGSetUserVideoCompressorList, 1,
27631      PyDoc_STR("(SGChannel c, Handle compressorTypes) -> (ComponentResult _rv)")},
27632     {"SGGetUserVideoCompressorList", (PyCFunction)Qt_SGGetUserVideoCompressorList, 1,
27633      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Handle compressorTypes)")},
27634     {"SGSetSoundInputDriver", (PyCFunction)Qt_SGSetSoundInputDriver, 1,
27635      PyDoc_STR("(SGChannel c, Str255 driverName) -> (ComponentResult _rv)")},
27636     {"SGGetSoundInputDriver", (PyCFunction)Qt_SGGetSoundInputDriver, 1,
27637      PyDoc_STR("(SGChannel c) -> (long _rv)")},
27638     {"SGSoundInputDriverChanged", (PyCFunction)Qt_SGSoundInputDriverChanged, 1,
27639      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv)")},
27640     {"SGSetSoundRecordChunkSize", (PyCFunction)Qt_SGSetSoundRecordChunkSize, 1,
27641      PyDoc_STR("(SGChannel c, long seconds) -> (ComponentResult _rv)")},
27642     {"SGGetSoundRecordChunkSize", (PyCFunction)Qt_SGGetSoundRecordChunkSize, 1,
27643      PyDoc_STR("(SGChannel c) -> (long _rv)")},
27644     {"SGSetSoundInputRate", (PyCFunction)Qt_SGSetSoundInputRate, 1,
27645      PyDoc_STR("(SGChannel c, Fixed rate) -> (ComponentResult _rv)")},
27646     {"SGGetSoundInputRate", (PyCFunction)Qt_SGGetSoundInputRate, 1,
27647      PyDoc_STR("(SGChannel c) -> (Fixed _rv)")},
27648     {"SGSetSoundInputParameters", (PyCFunction)Qt_SGSetSoundInputParameters, 1,
27649      PyDoc_STR("(SGChannel c, short sampleSize, short numChannels, OSType compressionType) -> (ComponentResult _rv)")},
27650     {"SGGetSoundInputParameters", (PyCFunction)Qt_SGGetSoundInputParameters, 1,
27651      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, short sampleSize, short numChannels, OSType compressionType)")},
27652     {"SGSetAdditionalSoundRates", (PyCFunction)Qt_SGSetAdditionalSoundRates, 1,
27653      PyDoc_STR("(SGChannel c, Handle rates) -> (ComponentResult _rv)")},
27654     {"SGGetAdditionalSoundRates", (PyCFunction)Qt_SGGetAdditionalSoundRates, 1,
27655      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, Handle rates)")},
27656     {"SGSetFontName", (PyCFunction)Qt_SGSetFontName, 1,
27657      PyDoc_STR("(SGChannel c, StringPtr pstr) -> (ComponentResult _rv)")},
27658     {"SGSetFontSize", (PyCFunction)Qt_SGSetFontSize, 1,
27659      PyDoc_STR("(SGChannel c, short fontSize) -> (ComponentResult _rv)")},
27660     {"SGSetTextForeColor", (PyCFunction)Qt_SGSetTextForeColor, 1,
27661      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, RGBColor theColor)")},
27662     {"SGSetTextBackColor", (PyCFunction)Qt_SGSetTextBackColor, 1,
27663      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, RGBColor theColor)")},
27664     {"SGSetJustification", (PyCFunction)Qt_SGSetJustification, 1,
27665      PyDoc_STR("(SGChannel c, short just) -> (ComponentResult _rv)")},
27666     {"SGGetTextReturnToSpaceValue", (PyCFunction)Qt_SGGetTextReturnToSpaceValue, 1,
27667      PyDoc_STR("(SGChannel c) -> (ComponentResult _rv, short rettospace)")},
27668     {"SGSetTextReturnToSpaceValue", (PyCFunction)Qt_SGSetTextReturnToSpaceValue, 1,
27669      PyDoc_STR("(SGChannel c, short rettospace) -> (ComponentResult _rv)")},
27670     {"QTVideoOutputGetCurrentClientName", (PyCFunction)Qt_QTVideoOutputGetCurrentClientName, 1,
27671      PyDoc_STR("(QTVideoOutputComponent vo, Str255 str) -> (ComponentResult _rv)")},
27672     {"QTVideoOutputSetClientName", (PyCFunction)Qt_QTVideoOutputSetClientName, 1,
27673      PyDoc_STR("(QTVideoOutputComponent vo, Str255 str) -> (ComponentResult _rv)")},
27674     {"QTVideoOutputGetClientName", (PyCFunction)Qt_QTVideoOutputGetClientName, 1,
27675      PyDoc_STR("(QTVideoOutputComponent vo, Str255 str) -> (ComponentResult _rv)")},
27676     {"QTVideoOutputBegin", (PyCFunction)Qt_QTVideoOutputBegin, 1,
27677      PyDoc_STR("(QTVideoOutputComponent vo) -> (ComponentResult _rv)")},
27678     {"QTVideoOutputEnd", (PyCFunction)Qt_QTVideoOutputEnd, 1,
27679      PyDoc_STR("(QTVideoOutputComponent vo) -> (ComponentResult _rv)")},
27680     {"QTVideoOutputSetDisplayMode", (PyCFunction)Qt_QTVideoOutputSetDisplayMode, 1,
27681      PyDoc_STR("(QTVideoOutputComponent vo, long displayModeID) -> (ComponentResult _rv)")},
27682     {"QTVideoOutputGetDisplayMode", (PyCFunction)Qt_QTVideoOutputGetDisplayMode, 1,
27683      PyDoc_STR("(QTVideoOutputComponent vo) -> (ComponentResult _rv, long displayModeID)")},
27684     {"QTVideoOutputGetGWorld", (PyCFunction)Qt_QTVideoOutputGetGWorld, 1,
27685      PyDoc_STR("(QTVideoOutputComponent vo) -> (ComponentResult _rv, GWorldPtr gw)")},
27686     {"QTVideoOutputGetIndSoundOutput", (PyCFunction)Qt_QTVideoOutputGetIndSoundOutput, 1,
27687      PyDoc_STR("(QTVideoOutputComponent vo, long index) -> (ComponentResult _rv, Component outputComponent)")},
27688     {"QTVideoOutputGetClock", (PyCFunction)Qt_QTVideoOutputGetClock, 1,
27689      PyDoc_STR("(QTVideoOutputComponent vo) -> (ComponentResult _rv, ComponentInstance clock)")},
27690     {"QTVideoOutputSetEchoPort", (PyCFunction)Qt_QTVideoOutputSetEchoPort, 1,
27691      PyDoc_STR("(QTVideoOutputComponent vo, CGrafPtr echoPort) -> (ComponentResult _rv)")},
27692     {"QTVideoOutputGetIndImageDecompressor", (PyCFunction)Qt_QTVideoOutputGetIndImageDecompressor, 1,
27693      PyDoc_STR("(QTVideoOutputComponent vo, long index) -> (ComponentResult _rv, Component codec)")},
27694     {"QTVideoOutputBaseSetEchoPort", (PyCFunction)Qt_QTVideoOutputBaseSetEchoPort, 1,
27695      PyDoc_STR("(QTVideoOutputComponent vo, CGrafPtr echoPort) -> (ComponentResult _rv)")},
27696     {"MediaSetChunkManagementFlags", (PyCFunction)Qt_MediaSetChunkManagementFlags, 1,
27697      PyDoc_STR("(MediaHandler mh, UInt32 flags, UInt32 flagsMask) -> (ComponentResult _rv)")},
27698     {"MediaGetChunkManagementFlags", (PyCFunction)Qt_MediaGetChunkManagementFlags, 1,
27699      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, UInt32 flags)")},
27700     {"MediaSetPurgeableChunkMemoryAllowance", (PyCFunction)Qt_MediaSetPurgeableChunkMemoryAllowance, 1,
27701      PyDoc_STR("(MediaHandler mh, Size allowance) -> (ComponentResult _rv)")},
27702     {"MediaGetPurgeableChunkMemoryAllowance", (PyCFunction)Qt_MediaGetPurgeableChunkMemoryAllowance, 1,
27703      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, Size allowance)")},
27704     {"MediaEmptyAllPurgeableChunks", (PyCFunction)Qt_MediaEmptyAllPurgeableChunks, 1,
27705      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
27706     {"MediaSetHandlerCapabilities", (PyCFunction)Qt_MediaSetHandlerCapabilities, 1,
27707      PyDoc_STR("(MediaHandler mh, long flags, long flagsMask) -> (ComponentResult _rv)")},
27708     {"MediaIdle", (PyCFunction)Qt_MediaIdle, 1,
27709      PyDoc_STR("(MediaHandler mh, TimeValue atMediaTime, long flagsIn, TimeRecord movieTime) -> (ComponentResult _rv, long flagsOut)")},
27710     {"MediaGetMediaInfo", (PyCFunction)Qt_MediaGetMediaInfo, 1,
27711      PyDoc_STR("(MediaHandler mh, Handle h) -> (ComponentResult _rv)")},
27712     {"MediaPutMediaInfo", (PyCFunction)Qt_MediaPutMediaInfo, 1,
27713      PyDoc_STR("(MediaHandler mh, Handle h) -> (ComponentResult _rv)")},
27714     {"MediaSetActive", (PyCFunction)Qt_MediaSetActive, 1,
27715      PyDoc_STR("(MediaHandler mh, Boolean enableMedia) -> (ComponentResult _rv)")},
27716     {"MediaSetRate", (PyCFunction)Qt_MediaSetRate, 1,
27717      PyDoc_STR("(MediaHandler mh, Fixed rate) -> (ComponentResult _rv)")},
27718     {"MediaGGetStatus", (PyCFunction)Qt_MediaGGetStatus, 1,
27719      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, ComponentResult statusErr)")},
27720     {"MediaTrackEdited", (PyCFunction)Qt_MediaTrackEdited, 1,
27721      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
27722     {"MediaSetMediaTimeScale", (PyCFunction)Qt_MediaSetMediaTimeScale, 1,
27723      PyDoc_STR("(MediaHandler mh, TimeScale newTimeScale) -> (ComponentResult _rv)")},
27724     {"MediaSetMovieTimeScale", (PyCFunction)Qt_MediaSetMovieTimeScale, 1,
27725      PyDoc_STR("(MediaHandler mh, TimeScale newTimeScale) -> (ComponentResult _rv)")},
27726     {"MediaSetGWorld", (PyCFunction)Qt_MediaSetGWorld, 1,
27727      PyDoc_STR("(MediaHandler mh, CGrafPtr aPort, GDHandle aGD) -> (ComponentResult _rv)")},
27728     {"MediaSetDimensions", (PyCFunction)Qt_MediaSetDimensions, 1,
27729      PyDoc_STR("(MediaHandler mh, Fixed width, Fixed height) -> (ComponentResult _rv)")},
27730     {"MediaSetClip", (PyCFunction)Qt_MediaSetClip, 1,
27731      PyDoc_STR("(MediaHandler mh, RgnHandle theClip) -> (ComponentResult _rv)")},
27732     {"MediaGetTrackOpaque", (PyCFunction)Qt_MediaGetTrackOpaque, 1,
27733      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, Boolean trackIsOpaque)")},
27734     {"MediaSetGraphicsMode", (PyCFunction)Qt_MediaSetGraphicsMode, 1,
27735      PyDoc_STR("(MediaHandler mh, long mode, RGBColor opColor) -> (ComponentResult _rv)")},
27736     {"MediaGetGraphicsMode", (PyCFunction)Qt_MediaGetGraphicsMode, 1,
27737      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, long mode, RGBColor opColor)")},
27738     {"MediaGSetVolume", (PyCFunction)Qt_MediaGSetVolume, 1,
27739      PyDoc_STR("(MediaHandler mh, short volume) -> (ComponentResult _rv)")},
27740     {"MediaSetSoundBalance", (PyCFunction)Qt_MediaSetSoundBalance, 1,
27741      PyDoc_STR("(MediaHandler mh, short balance) -> (ComponentResult _rv)")},
27742     {"MediaGetSoundBalance", (PyCFunction)Qt_MediaGetSoundBalance, 1,
27743      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, short balance)")},
27744     {"MediaGetNextBoundsChange", (PyCFunction)Qt_MediaGetNextBoundsChange, 1,
27745      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, TimeValue when)")},
27746     {"MediaGetSrcRgn", (PyCFunction)Qt_MediaGetSrcRgn, 1,
27747      PyDoc_STR("(MediaHandler mh, RgnHandle rgn, TimeValue atMediaTime) -> (ComponentResult _rv)")},
27748     {"MediaPreroll", (PyCFunction)Qt_MediaPreroll, 1,
27749      PyDoc_STR("(MediaHandler mh, TimeValue time, Fixed rate) -> (ComponentResult _rv)")},
27750     {"MediaSampleDescriptionChanged", (PyCFunction)Qt_MediaSampleDescriptionChanged, 1,
27751      PyDoc_STR("(MediaHandler mh, long index) -> (ComponentResult _rv)")},
27752     {"MediaHasCharacteristic", (PyCFunction)Qt_MediaHasCharacteristic, 1,
27753      PyDoc_STR("(MediaHandler mh, OSType characteristic) -> (ComponentResult _rv, Boolean hasIt)")},
27754     {"MediaGetOffscreenBufferSize", (PyCFunction)Qt_MediaGetOffscreenBufferSize, 1,
27755      PyDoc_STR("(MediaHandler mh, short depth, CTabHandle ctab) -> (ComponentResult _rv, Rect bounds)")},
27756     {"MediaSetHints", (PyCFunction)Qt_MediaSetHints, 1,
27757      PyDoc_STR("(MediaHandler mh, long hints) -> (ComponentResult _rv)")},
27758     {"MediaGetName", (PyCFunction)Qt_MediaGetName, 1,
27759      PyDoc_STR("(MediaHandler mh, Str255 name, long requestedLanguage) -> (ComponentResult _rv, long actualLanguage)")},
27760     {"MediaForceUpdate", (PyCFunction)Qt_MediaForceUpdate, 1,
27761      PyDoc_STR("(MediaHandler mh, long forceUpdateFlags) -> (ComponentResult _rv)")},
27762     {"MediaGetDrawingRgn", (PyCFunction)Qt_MediaGetDrawingRgn, 1,
27763      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, RgnHandle partialRgn)")},
27764     {"MediaGSetActiveSegment", (PyCFunction)Qt_MediaGSetActiveSegment, 1,
27765      PyDoc_STR("(MediaHandler mh, TimeValue activeStart, TimeValue activeDuration) -> (ComponentResult _rv)")},
27766     {"MediaInvalidateRegion", (PyCFunction)Qt_MediaInvalidateRegion, 1,
27767      PyDoc_STR("(MediaHandler mh, RgnHandle invalRgn) -> (ComponentResult _rv)")},
27768     {"MediaGetNextStepTime", (PyCFunction)Qt_MediaGetNextStepTime, 1,
27769      PyDoc_STR("(MediaHandler mh, short flags, TimeValue mediaTimeIn, Fixed rate) -> (ComponentResult _rv, TimeValue mediaTimeOut)")},
27770     {"MediaChangedNonPrimarySource", (PyCFunction)Qt_MediaChangedNonPrimarySource, 1,
27771      PyDoc_STR("(MediaHandler mh, long inputIndex) -> (ComponentResult _rv)")},
27772     {"MediaTrackReferencesChanged", (PyCFunction)Qt_MediaTrackReferencesChanged, 1,
27773      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
27774     {"MediaReleaseSampleDataPointer", (PyCFunction)Qt_MediaReleaseSampleDataPointer, 1,
27775      PyDoc_STR("(MediaHandler mh, long sampleNum) -> (ComponentResult _rv)")},
27776     {"MediaTrackPropertyAtomChanged", (PyCFunction)Qt_MediaTrackPropertyAtomChanged, 1,
27777      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
27778     {"MediaSetVideoParam", (PyCFunction)Qt_MediaSetVideoParam, 1,
27779      PyDoc_STR("(MediaHandler mh, long whichParam) -> (ComponentResult _rv, unsigned short value)")},
27780     {"MediaGetVideoParam", (PyCFunction)Qt_MediaGetVideoParam, 1,
27781      PyDoc_STR("(MediaHandler mh, long whichParam) -> (ComponentResult _rv, unsigned short value)")},
27782     {"MediaCompare", (PyCFunction)Qt_MediaCompare, 1,
27783      PyDoc_STR("(MediaHandler mh, Media srcMedia, ComponentInstance srcMediaComponent) -> (ComponentResult _rv, Boolean isOK)")},
27784     {"MediaGetClock", (PyCFunction)Qt_MediaGetClock, 1,
27785      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, ComponentInstance clock)")},
27786     {"MediaSetSoundOutputComponent", (PyCFunction)Qt_MediaSetSoundOutputComponent, 1,
27787      PyDoc_STR("(MediaHandler mh, Component outputComponent) -> (ComponentResult _rv)")},
27788     {"MediaGetSoundOutputComponent", (PyCFunction)Qt_MediaGetSoundOutputComponent, 1,
27789      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, Component outputComponent)")},
27790     {"MediaSetSoundLocalizationData", (PyCFunction)Qt_MediaSetSoundLocalizationData, 1,
27791      PyDoc_STR("(MediaHandler mh, Handle data) -> (ComponentResult _rv)")},
27792     {"MediaGetInvalidRegion", (PyCFunction)Qt_MediaGetInvalidRegion, 1,
27793      PyDoc_STR("(MediaHandler mh, RgnHandle rgn) -> (ComponentResult _rv)")},
27794     {"MediaSampleDescriptionB2N", (PyCFunction)Qt_MediaSampleDescriptionB2N, 1,
27795      PyDoc_STR("(MediaHandler mh, SampleDescriptionHandle sampleDescriptionH) -> (ComponentResult _rv)")},
27796     {"MediaSampleDescriptionN2B", (PyCFunction)Qt_MediaSampleDescriptionN2B, 1,
27797      PyDoc_STR("(MediaHandler mh, SampleDescriptionHandle sampleDescriptionH) -> (ComponentResult _rv)")},
27798     {"MediaFlushNonPrimarySourceData", (PyCFunction)Qt_MediaFlushNonPrimarySourceData, 1,
27799      PyDoc_STR("(MediaHandler mh, long inputIndex) -> (ComponentResult _rv)")},
27800     {"MediaGetURLLink", (PyCFunction)Qt_MediaGetURLLink, 1,
27801      PyDoc_STR("(MediaHandler mh, Point displayWhere) -> (ComponentResult _rv, Handle urlLink)")},
27802     {"MediaHitTestForTargetRefCon", (PyCFunction)Qt_MediaHitTestForTargetRefCon, 1,
27803      PyDoc_STR("(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, long targetRefCon)")},
27804     {"MediaHitTestTargetRefCon", (PyCFunction)Qt_MediaHitTestTargetRefCon, 1,
27805      PyDoc_STR("(MediaHandler mh, long targetRefCon, long flags, Point loc) -> (ComponentResult _rv, Boolean wasHit)")},
27806     {"MediaDisposeTargetRefCon", (PyCFunction)Qt_MediaDisposeTargetRefCon, 1,
27807      PyDoc_STR("(MediaHandler mh, long targetRefCon) -> (ComponentResult _rv)")},
27808     {"MediaTargetRefConsEqual", (PyCFunction)Qt_MediaTargetRefConsEqual, 1,
27809      PyDoc_STR("(MediaHandler mh, long firstRefCon, long secondRefCon) -> (ComponentResult _rv, Boolean equal)")},
27810     {"MediaPrePrerollCancel", (PyCFunction)Qt_MediaPrePrerollCancel, 1,
27811      PyDoc_STR("(MediaHandler mh, void * refcon) -> (ComponentResult _rv)")},
27812     {"MediaEnterEmptyEdit", (PyCFunction)Qt_MediaEnterEmptyEdit, 1,
27813      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
27814     {"MediaCurrentMediaQueuedData", (PyCFunction)Qt_MediaCurrentMediaQueuedData, 1,
27815      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, long milliSecs)")},
27816     {"MediaGetEffectiveVolume", (PyCFunction)Qt_MediaGetEffectiveVolume, 1,
27817      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, short volume)")},
27818     {"MediaGetSoundLevelMeteringEnabled", (PyCFunction)Qt_MediaGetSoundLevelMeteringEnabled, 1,
27819      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, Boolean enabled)")},
27820     {"MediaSetSoundLevelMeteringEnabled", (PyCFunction)Qt_MediaSetSoundLevelMeteringEnabled, 1,
27821      PyDoc_STR("(MediaHandler mh, Boolean enable) -> (ComponentResult _rv)")},
27822     {"MediaGetEffectiveSoundBalance", (PyCFunction)Qt_MediaGetEffectiveSoundBalance, 1,
27823      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, short balance)")},
27824     {"MediaSetScreenLock", (PyCFunction)Qt_MediaSetScreenLock, 1,
27825      PyDoc_STR("(MediaHandler mh, Boolean lockIt) -> (ComponentResult _rv)")},
27826     {"MediaGetErrorString", (PyCFunction)Qt_MediaGetErrorString, 1,
27827      PyDoc_STR("(MediaHandler mh, ComponentResult theError, Str255 errorString) -> (ComponentResult _rv)")},
27828     {"MediaGetSoundEqualizerBandLevels", (PyCFunction)Qt_MediaGetSoundEqualizerBandLevels, 1,
27829      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, UInt8 bandLevels)")},
27830     {"MediaDoIdleActions", (PyCFunction)Qt_MediaDoIdleActions, 1,
27831      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
27832     {"MediaSetSoundBassAndTreble", (PyCFunction)Qt_MediaSetSoundBassAndTreble, 1,
27833      PyDoc_STR("(MediaHandler mh, short bass, short treble) -> (ComponentResult _rv)")},
27834     {"MediaGetSoundBassAndTreble", (PyCFunction)Qt_MediaGetSoundBassAndTreble, 1,
27835      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, short bass, short treble)")},
27836     {"MediaTimeBaseChanged", (PyCFunction)Qt_MediaTimeBaseChanged, 1,
27837      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
27838     {"MediaMCIsPlayerEvent", (PyCFunction)Qt_MediaMCIsPlayerEvent, 1,
27839      PyDoc_STR("(MediaHandler mh, EventRecord e) -> (ComponentResult _rv, Boolean handledIt)")},
27840     {"MediaGetMediaLoadState", (PyCFunction)Qt_MediaGetMediaLoadState, 1,
27841      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, long mediaLoadState)")},
27842     {"MediaVideoOutputChanged", (PyCFunction)Qt_MediaVideoOutputChanged, 1,
27843      PyDoc_STR("(MediaHandler mh, ComponentInstance vout) -> (ComponentResult _rv)")},
27844     {"MediaEmptySampleCache", (PyCFunction)Qt_MediaEmptySampleCache, 1,
27845      PyDoc_STR("(MediaHandler mh, long sampleNum, long sampleCount) -> (ComponentResult _rv)")},
27846     {"MediaGetPublicInfo", (PyCFunction)Qt_MediaGetPublicInfo, 1,
27847      PyDoc_STR("(MediaHandler mh, OSType infoSelector, void * infoDataPtr) -> (ComponentResult _rv, Size ioDataSize)")},
27848     {"MediaSetPublicInfo", (PyCFunction)Qt_MediaSetPublicInfo, 1,
27849      PyDoc_STR("(MediaHandler mh, OSType infoSelector, void * infoDataPtr, Size dataSize) -> (ComponentResult _rv)")},
27850     {"MediaRefConSetProperty", (PyCFunction)Qt_MediaRefConSetProperty, 1,
27851      PyDoc_STR("(MediaHandler mh, long refCon, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
27852     {"MediaRefConGetProperty", (PyCFunction)Qt_MediaRefConGetProperty, 1,
27853      PyDoc_STR("(MediaHandler mh, long refCon, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
27854     {"MediaNavigateTargetRefCon", (PyCFunction)Qt_MediaNavigateTargetRefCon, 1,
27855      PyDoc_STR("(MediaHandler mh, long navigation) -> (ComponentResult _rv, long refCon)")},
27856     {"MediaGGetIdleManager", (PyCFunction)Qt_MediaGGetIdleManager, 1,
27857      PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, IdleManager pim)")},
27858     {"MediaGSetIdleManager", (PyCFunction)Qt_MediaGSetIdleManager, 1,
27859      PyDoc_STR("(MediaHandler mh, IdleManager im) -> (ComponentResult _rv)")},
27860     {"QTMIDIGetMIDIPorts", (PyCFunction)Qt_QTMIDIGetMIDIPorts, 1,
27861      PyDoc_STR("(QTMIDIComponent ci) -> (ComponentResult _rv, QTMIDIPortListHandle inputPorts, QTMIDIPortListHandle outputPorts)")},
27862     {"QTMIDIUseSendPort", (PyCFunction)Qt_QTMIDIUseSendPort, 1,
27863      PyDoc_STR("(QTMIDIComponent ci, long portIndex, long inUse) -> (ComponentResult _rv)")},
27864     {"QTMIDISendMIDI", (PyCFunction)Qt_QTMIDISendMIDI, 1,
27865      PyDoc_STR("(QTMIDIComponent ci, long portIndex, MusicMIDIPacket mp) -> (ComponentResult _rv)")},
27866     {"MusicGetPart", (PyCFunction)Qt_MusicGetPart, 1,
27867      PyDoc_STR("(MusicComponent mc, long part) -> (ComponentResult _rv, long midiChannel, long polyphony)")},
27868     {"MusicSetPart", (PyCFunction)Qt_MusicSetPart, 1,
27869      PyDoc_STR("(MusicComponent mc, long part, long midiChannel, long polyphony) -> (ComponentResult _rv)")},
27870     {"MusicSetPartInstrumentNumber", (PyCFunction)Qt_MusicSetPartInstrumentNumber, 1,
27871      PyDoc_STR("(MusicComponent mc, long part, long instrumentNumber) -> (ComponentResult _rv)")},
27872     {"MusicGetPartInstrumentNumber", (PyCFunction)Qt_MusicGetPartInstrumentNumber, 1,
27873      PyDoc_STR("(MusicComponent mc, long part) -> (ComponentResult _rv)")},
27874     {"MusicStorePartInstrument", (PyCFunction)Qt_MusicStorePartInstrument, 1,
27875      PyDoc_STR("(MusicComponent mc, long part, long instrumentNumber) -> (ComponentResult _rv)")},
27876     {"MusicGetPartAtomicInstrument", (PyCFunction)Qt_MusicGetPartAtomicInstrument, 1,
27877      PyDoc_STR("(MusicComponent mc, long part, long flags) -> (ComponentResult _rv, AtomicInstrument ai)")},
27878     {"MusicSetPartAtomicInstrument", (PyCFunction)Qt_MusicSetPartAtomicInstrument, 1,
27879      PyDoc_STR("(MusicComponent mc, long part, AtomicInstrumentPtr aiP, long flags) -> (ComponentResult _rv)")},
27880     {"MusicGetPartKnob", (PyCFunction)Qt_MusicGetPartKnob, 1,
27881      PyDoc_STR("(MusicComponent mc, long part, long knobID) -> (ComponentResult _rv)")},
27882     {"MusicSetPartKnob", (PyCFunction)Qt_MusicSetPartKnob, 1,
27883      PyDoc_STR("(MusicComponent mc, long part, long knobID, long knobValue) -> (ComponentResult _rv)")},
27884     {"MusicGetKnob", (PyCFunction)Qt_MusicGetKnob, 1,
27885      PyDoc_STR("(MusicComponent mc, long knobID) -> (ComponentResult _rv)")},
27886     {"MusicSetKnob", (PyCFunction)Qt_MusicSetKnob, 1,
27887      PyDoc_STR("(MusicComponent mc, long knobID, long knobValue) -> (ComponentResult _rv)")},
27888     {"MusicGetPartName", (PyCFunction)Qt_MusicGetPartName, 1,
27889      PyDoc_STR("(MusicComponent mc, long part, StringPtr name) -> (ComponentResult _rv)")},
27890     {"MusicSetPartName", (PyCFunction)Qt_MusicSetPartName, 1,
27891      PyDoc_STR("(MusicComponent mc, long part, StringPtr name) -> (ComponentResult _rv)")},
27892     {"MusicPlayNote", (PyCFunction)Qt_MusicPlayNote, 1,
27893      PyDoc_STR("(MusicComponent mc, long part, long pitch, long velocity) -> (ComponentResult _rv)")},
27894     {"MusicResetPart", (PyCFunction)Qt_MusicResetPart, 1,
27895      PyDoc_STR("(MusicComponent mc, long part) -> (ComponentResult _rv)")},
27896     {"MusicSetPartController", (PyCFunction)Qt_MusicSetPartController, 1,
27897      PyDoc_STR("(MusicComponent mc, long part, MusicController controllerNumber, long controllerValue) -> (ComponentResult _rv)")},
27898     {"MusicGetPartController", (PyCFunction)Qt_MusicGetPartController, 1,
27899      PyDoc_STR("(MusicComponent mc, long part, MusicController controllerNumber) -> (ComponentResult _rv)")},
27900     {"MusicGetInstrumentNames", (PyCFunction)Qt_MusicGetInstrumentNames, 1,
27901      PyDoc_STR("(MusicComponent mc, long modifiableInstruments) -> (ComponentResult _rv, Handle instrumentNames, Handle instrumentCategoryLasts, Handle instrumentCategoryNames)")},
27902     {"MusicGetDrumNames", (PyCFunction)Qt_MusicGetDrumNames, 1,
27903      PyDoc_STR("(MusicComponent mc, long modifiableInstruments) -> (ComponentResult _rv, Handle instrumentNumbers, Handle instrumentNames)")},
27904     {"MusicGetMasterTune", (PyCFunction)Qt_MusicGetMasterTune, 1,
27905      PyDoc_STR("(MusicComponent mc) -> (ComponentResult _rv)")},
27906     {"MusicSetMasterTune", (PyCFunction)Qt_MusicSetMasterTune, 1,
27907      PyDoc_STR("(MusicComponent mc, long masterTune) -> (ComponentResult _rv)")},
27908     {"MusicGetDeviceConnection", (PyCFunction)Qt_MusicGetDeviceConnection, 1,
27909      PyDoc_STR("(MusicComponent mc, long index) -> (ComponentResult _rv, long id1, long id2)")},
27910     {"MusicUseDeviceConnection", (PyCFunction)Qt_MusicUseDeviceConnection, 1,
27911      PyDoc_STR("(MusicComponent mc, long id1, long id2) -> (ComponentResult _rv)")},
27912     {"MusicGetKnobSettingStrings", (PyCFunction)Qt_MusicGetKnobSettingStrings, 1,
27913      PyDoc_STR("(MusicComponent mc, long knobIndex, long isGlobal) -> (ComponentResult _rv, Handle settingsNames, Handle settingsCategoryLasts, Handle settingsCategoryNames)")},
27914     {"MusicGetMIDIPorts", (PyCFunction)Qt_MusicGetMIDIPorts, 1,
27915      PyDoc_STR("(MusicComponent mc) -> (ComponentResult _rv, long inputPortCount, long outputPortCount)")},
27916     {"MusicSendMIDI", (PyCFunction)Qt_MusicSendMIDI, 1,
27917      PyDoc_STR("(MusicComponent mc, long portIndex, MusicMIDIPacket mp) -> (ComponentResult _rv)")},
27918     {"MusicSetOfflineTimeTo", (PyCFunction)Qt_MusicSetOfflineTimeTo, 1,
27919      PyDoc_STR("(MusicComponent mc, long newTimeStamp) -> (ComponentResult _rv)")},
27920     {"MusicGetInfoText", (PyCFunction)Qt_MusicGetInfoText, 1,
27921      PyDoc_STR("(MusicComponent mc, long selector) -> (ComponentResult _rv, Handle textH, Handle styleH)")},
27922     {"MusicGetInstrumentInfo", (PyCFunction)Qt_MusicGetInstrumentInfo, 1,
27923      PyDoc_STR("(MusicComponent mc, long getInstrumentInfoFlags) -> (ComponentResult _rv, InstrumentInfoListHandle infoListH)")},
27924     {"MusicTask", (PyCFunction)Qt_MusicTask, 1,
27925      PyDoc_STR("(MusicComponent mc) -> (ComponentResult _rv)")},
27926     {"MusicSetPartInstrumentNumberInterruptSafe", (PyCFunction)Qt_MusicSetPartInstrumentNumberInterruptSafe, 1,
27927      PyDoc_STR("(MusicComponent mc, long part, long instrumentNumber) -> (ComponentResult _rv)")},
27928     {"MusicSetPartSoundLocalization", (PyCFunction)Qt_MusicSetPartSoundLocalization, 1,
27929      PyDoc_STR("(MusicComponent mc, long part, Handle data) -> (ComponentResult _rv)")},
27930     {"MusicGenericConfigure", (PyCFunction)Qt_MusicGenericConfigure, 1,
27931      PyDoc_STR("(MusicComponent mc, long mode, long flags, long baseResID) -> (ComponentResult _rv)")},
27932     {"MusicGenericGetKnobList", (PyCFunction)Qt_MusicGenericGetKnobList, 1,
27933      PyDoc_STR("(MusicComponent mc, long knobType) -> (ComponentResult _rv, GenericKnobDescriptionListHandle gkdlH)")},
27934     {"MusicGenericSetResourceNumbers", (PyCFunction)Qt_MusicGenericSetResourceNumbers, 1,
27935      PyDoc_STR("(MusicComponent mc, Handle resourceIDH) -> (ComponentResult _rv)")},
27936     {"MusicDerivedMIDISend", (PyCFunction)Qt_MusicDerivedMIDISend, 1,
27937      PyDoc_STR("(MusicComponent mc, MusicMIDIPacket packet) -> (ComponentResult _rv)")},
27938     {"MusicDerivedOpenResFile", (PyCFunction)Qt_MusicDerivedOpenResFile, 1,
27939      PyDoc_STR("(MusicComponent mc) -> (ComponentResult _rv)")},
27940     {"MusicDerivedCloseResFile", (PyCFunction)Qt_MusicDerivedCloseResFile, 1,
27941      PyDoc_STR("(MusicComponent mc, short resRefNum) -> (ComponentResult _rv)")},
27942     {"NAUnregisterMusicDevice", (PyCFunction)Qt_NAUnregisterMusicDevice, 1,
27943      PyDoc_STR("(NoteAllocator na, long index) -> (ComponentResult _rv)")},
27944     {"NASaveMusicConfiguration", (PyCFunction)Qt_NASaveMusicConfiguration, 1,
27945      PyDoc_STR("(NoteAllocator na) -> (ComponentResult _rv)")},
27946     {"NAGetMIDIPorts", (PyCFunction)Qt_NAGetMIDIPorts, 1,
27947      PyDoc_STR("(NoteAllocator na) -> (ComponentResult _rv, QTMIDIPortListHandle inputPorts, QTMIDIPortListHandle outputPorts)")},
27948     {"NATask", (PyCFunction)Qt_NATask, 1,
27949      PyDoc_STR("(NoteAllocator na) -> (ComponentResult _rv)")},
27950     {"TuneSetHeader", (PyCFunction)Qt_TuneSetHeader, 1,
27951      PyDoc_STR("(TunePlayer tp, unsigned long * header) -> (ComponentResult _rv)")},
27952     {"TuneGetTimeBase", (PyCFunction)Qt_TuneGetTimeBase, 1,
27953      PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv, TimeBase tb)")},
27954     {"TuneSetTimeScale", (PyCFunction)Qt_TuneSetTimeScale, 1,
27955      PyDoc_STR("(TunePlayer tp, TimeScale scale) -> (ComponentResult _rv)")},
27956     {"TuneGetTimeScale", (PyCFunction)Qt_TuneGetTimeScale, 1,
27957      PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv, TimeScale scale)")},
27958     {"TuneInstant", (PyCFunction)Qt_TuneInstant, 1,
27959      PyDoc_STR("(TunePlayer tp, unsigned long tunePosition) -> (ComponentResult _rv, unsigned long tune)")},
27960     {"TuneStop", (PyCFunction)Qt_TuneStop, 1,
27961      PyDoc_STR("(TunePlayer tp, long stopFlags) -> (ComponentResult _rv)")},
27962     {"TuneSetVolume", (PyCFunction)Qt_TuneSetVolume, 1,
27963      PyDoc_STR("(TunePlayer tp, Fixed volume) -> (ComponentResult _rv)")},
27964     {"TuneGetVolume", (PyCFunction)Qt_TuneGetVolume, 1,
27965      PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv)")},
27966     {"TunePreroll", (PyCFunction)Qt_TunePreroll, 1,
27967      PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv)")},
27968     {"TuneUnroll", (PyCFunction)Qt_TuneUnroll, 1,
27969      PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv)")},
27970     {"TuneSetPartTranspose", (PyCFunction)Qt_TuneSetPartTranspose, 1,
27971      PyDoc_STR("(TunePlayer tp, unsigned long part, long transpose, long velocityShift) -> (ComponentResult _rv)")},
27972     {"TuneGetNoteAllocator", (PyCFunction)Qt_TuneGetNoteAllocator, 1,
27973      PyDoc_STR("(TunePlayer tp) -> (NoteAllocator _rv)")},
27974     {"TuneSetSofter", (PyCFunction)Qt_TuneSetSofter, 1,
27975      PyDoc_STR("(TunePlayer tp, long softer) -> (ComponentResult _rv)")},
27976     {"TuneTask", (PyCFunction)Qt_TuneTask, 1,
27977      PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv)")},
27978     {"TuneSetBalance", (PyCFunction)Qt_TuneSetBalance, 1,
27979      PyDoc_STR("(TunePlayer tp, long balance) -> (ComponentResult _rv)")},
27980     {"TuneSetSoundLocalization", (PyCFunction)Qt_TuneSetSoundLocalization, 1,
27981      PyDoc_STR("(TunePlayer tp, Handle data) -> (ComponentResult _rv)")},
27982     {"TuneSetHeaderWithSize", (PyCFunction)Qt_TuneSetHeaderWithSize, 1,
27983      PyDoc_STR("(TunePlayer tp, unsigned long * header, unsigned long size) -> (ComponentResult _rv)")},
27984     {"TuneSetPartMix", (PyCFunction)Qt_TuneSetPartMix, 1,
27985      PyDoc_STR("(TunePlayer tp, unsigned long partNumber, long volume, long balance, long mixFlags) -> (ComponentResult _rv)")},
27986     {"TuneGetPartMix", (PyCFunction)Qt_TuneGetPartMix, 1,
27987      PyDoc_STR("(TunePlayer tp, unsigned long partNumber) -> (ComponentResult _rv, long volumeOut, long balanceOut, long mixFlagsOut)")},
27988     {"AlignWindow", (PyCFunction)Qt_AlignWindow, 1,
27989      PyDoc_STR("(WindowPtr wp, Boolean front) -> None")},
27990     {"DragAlignedWindow", (PyCFunction)Qt_DragAlignedWindow, 1,
27991      PyDoc_STR("(WindowPtr wp, Point startPt, Rect boundsRect) -> None")},
27992     {"MoviesTask", (PyCFunction)Qt_MoviesTask, 1,
27993      PyDoc_STR("(long maxMilliSecToUse) -> None")},
27994 #endif /* __LP64__ */
27995     {NULL, NULL, 0}
27996 };
27997
27998
27999
28000
28001 void init_Qt(void)
28002 {
28003     PyObject *m;
28004 #ifndef __LP64__
28005     PyObject *d;
28006
28007
28008
28009         PyMac_INIT_TOOLBOX_OBJECT_NEW(Track, TrackObj_New);
28010         PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Track, TrackObj_Convert);
28011         PyMac_INIT_TOOLBOX_OBJECT_NEW(Movie, MovieObj_New);
28012         PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Movie, MovieObj_Convert);
28013         PyMac_INIT_TOOLBOX_OBJECT_NEW(MovieController, MovieCtlObj_New);
28014         PyMac_INIT_TOOLBOX_OBJECT_CONVERT(MovieController, MovieCtlObj_Convert);
28015         PyMac_INIT_TOOLBOX_OBJECT_NEW(TimeBase, TimeBaseObj_New);
28016         PyMac_INIT_TOOLBOX_OBJECT_CONVERT(TimeBase, TimeBaseObj_Convert);
28017         PyMac_INIT_TOOLBOX_OBJECT_NEW(UserData, UserDataObj_New);
28018         PyMac_INIT_TOOLBOX_OBJECT_CONVERT(UserData, UserDataObj_Convert);
28019         PyMac_INIT_TOOLBOX_OBJECT_NEW(Media, MediaObj_New);
28020         PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Media, MediaObj_Convert);
28021 #endif /* __LP64__ */
28022
28023
28024     m = Py_InitModule("_Qt", Qt_methods);
28025 #ifndef __LP64__
28026     d = PyModule_GetDict(m);
28027     Qt_Error = PyMac_GetOSErrException();
28028     if (Qt_Error == NULL ||
28029         PyDict_SetItemString(d, "Error", Qt_Error) != 0)
28030         return;
28031     IdleManager_Type.ob_type = &PyType_Type;
28032     if (PyType_Ready(&IdleManager_Type) < 0) return;
28033     Py_INCREF(&IdleManager_Type);
28034     PyModule_AddObject(m, "IdleManager", (PyObject *)&IdleManager_Type);
28035     /* Backward-compatible name */
28036     Py_INCREF(&IdleManager_Type);
28037     PyModule_AddObject(m, "IdleManagerType", (PyObject *)&IdleManager_Type);
28038     MovieController_Type.ob_type = &PyType_Type;
28039     if (PyType_Ready(&MovieController_Type) < 0) return;
28040     Py_INCREF(&MovieController_Type);
28041     PyModule_AddObject(m, "MovieController", (PyObject *)&MovieController_Type);
28042     /* Backward-compatible name */
28043     Py_INCREF(&MovieController_Type);
28044     PyModule_AddObject(m, "MovieControllerType", (PyObject *)&MovieController_Type);
28045     TimeBase_Type.ob_type = &PyType_Type;
28046     if (PyType_Ready(&TimeBase_Type) < 0) return;
28047     Py_INCREF(&TimeBase_Type);
28048     PyModule_AddObject(m, "TimeBase", (PyObject *)&TimeBase_Type);
28049     /* Backward-compatible name */
28050     Py_INCREF(&TimeBase_Type);
28051     PyModule_AddObject(m, "TimeBaseType", (PyObject *)&TimeBase_Type);
28052     UserData_Type.ob_type = &PyType_Type;
28053     if (PyType_Ready(&UserData_Type) < 0) return;
28054     Py_INCREF(&UserData_Type);
28055     PyModule_AddObject(m, "UserData", (PyObject *)&UserData_Type);
28056     /* Backward-compatible name */
28057     Py_INCREF(&UserData_Type);
28058     PyModule_AddObject(m, "UserDataType", (PyObject *)&UserData_Type);
28059     Media_Type.ob_type = &PyType_Type;
28060     if (PyType_Ready(&Media_Type) < 0) return;
28061     Py_INCREF(&Media_Type);
28062     PyModule_AddObject(m, "Media", (PyObject *)&Media_Type);
28063     /* Backward-compatible name */
28064     Py_INCREF(&Media_Type);
28065     PyModule_AddObject(m, "MediaType", (PyObject *)&Media_Type);
28066     Track_Type.ob_type = &PyType_Type;
28067     if (PyType_Ready(&Track_Type) < 0) return;
28068     Py_INCREF(&Track_Type);
28069     PyModule_AddObject(m, "Track", (PyObject *)&Track_Type);
28070     /* Backward-compatible name */
28071     Py_INCREF(&Track_Type);
28072     PyModule_AddObject(m, "TrackType", (PyObject *)&Track_Type);
28073     Movie_Type.ob_type = &PyType_Type;
28074     if (PyType_Ready(&Movie_Type) < 0) return;
28075     Py_INCREF(&Movie_Type);
28076     PyModule_AddObject(m, "Movie", (PyObject *)&Movie_Type);
28077     /* Backward-compatible name */
28078     Py_INCREF(&Movie_Type);
28079     PyModule_AddObject(m, "MovieType", (PyObject *)&Movie_Type);
28080     SGOutput_Type.ob_type = &PyType_Type;
28081     if (PyType_Ready(&SGOutput_Type) < 0) return;
28082     Py_INCREF(&SGOutput_Type);
28083     PyModule_AddObject(m, "SGOutput", (PyObject *)&SGOutput_Type);
28084     /* Backward-compatible name */
28085     Py_INCREF(&SGOutput_Type);
28086     PyModule_AddObject(m, "SGOutputType", (PyObject *)&SGOutput_Type);
28087 #endif /* __LP64__ */
28088 }
28089
28090 /* ========================= End module _Qt ========================= */
28091