Added support for APIs in QuickTimeMusic.h. This one is a bit dodgy:
the header file seems to be hand-written and missing the "const" keywords
for input parameters passed by reference.
diff --git a/Mac/Modules/qt/_Qtmodule.c b/Mac/Modules/qt/_Qtmodule.c
index 74121af..b201021 100644
--- a/Mac/Modules/qt/_Qtmodule.c
+++ b/Mac/Modules/qt/_Qtmodule.c
@@ -78,6 +78,16 @@
return 1;
}
+static int
+QtMusicMIDIPacket_Convert(PyObject *v, MusicMIDIPacket *p_itself)
+{
+ int dummy;
+
+ if( !PyArg_ParseTuple(v, "hls#", &p_itself->length, &p_itself->reserved, p_itself->data, dummy) )
+ return 0;
+ return 1;
+}
+
@@ -24794,6 +24804,1427 @@
return _res;
}
+static PyObject *Qt_QTMIDIGetMIDIPorts(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ QTMIDIComponent ci;
+ QTMIDIPortListHandle inputPorts;
+ QTMIDIPortListHandle outputPorts;
+#ifndef QTMIDIGetMIDIPorts
+ PyMac_PRECHECK(QTMIDIGetMIDIPorts);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &ci))
+ return NULL;
+ _rv = QTMIDIGetMIDIPorts(ci,
+ &inputPorts,
+ &outputPorts);
+ _res = Py_BuildValue("lO&O&",
+ _rv,
+ ResObj_New, inputPorts,
+ ResObj_New, outputPorts);
+ return _res;
+}
+
+static PyObject *Qt_QTMIDIUseSendPort(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ QTMIDIComponent ci;
+ long portIndex;
+ long inUse;
+#ifndef QTMIDIUseSendPort
+ PyMac_PRECHECK(QTMIDIUseSendPort);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&ll",
+ CmpInstObj_Convert, &ci,
+ &portIndex,
+ &inUse))
+ return NULL;
+ _rv = QTMIDIUseSendPort(ci,
+ portIndex,
+ inUse);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_QTMIDISendMIDI(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ QTMIDIComponent ci;
+ long portIndex;
+ MusicMIDIPacket mp;
+#ifndef QTMIDISendMIDI
+ PyMac_PRECHECK(QTMIDISendMIDI);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&lO&",
+ CmpInstObj_Convert, &ci,
+ &portIndex,
+ QtMusicMIDIPacket_Convert, &mp))
+ return NULL;
+ _rv = QTMIDISendMIDI(ci,
+ portIndex,
+ &mp);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicGetPart(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long part;
+ long midiChannel;
+ long polyphony;
+#ifndef MusicGetPart
+ PyMac_PRECHECK(MusicGetPart);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mc,
+ &part))
+ return NULL;
+ _rv = MusicGetPart(mc,
+ part,
+ &midiChannel,
+ &polyphony);
+ _res = Py_BuildValue("lll",
+ _rv,
+ midiChannel,
+ polyphony);
+ return _res;
+}
+
+static PyObject *Qt_MusicSetPart(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long part;
+ long midiChannel;
+ long polyphony;
+#ifndef MusicSetPart
+ PyMac_PRECHECK(MusicSetPart);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&lll",
+ CmpInstObj_Convert, &mc,
+ &part,
+ &midiChannel,
+ &polyphony))
+ return NULL;
+ _rv = MusicSetPart(mc,
+ part,
+ midiChannel,
+ polyphony);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicSetPartInstrumentNumber(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long part;
+ long instrumentNumber;
+#ifndef MusicSetPartInstrumentNumber
+ PyMac_PRECHECK(MusicSetPartInstrumentNumber);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&ll",
+ CmpInstObj_Convert, &mc,
+ &part,
+ &instrumentNumber))
+ return NULL;
+ _rv = MusicSetPartInstrumentNumber(mc,
+ part,
+ instrumentNumber);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicGetPartInstrumentNumber(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long part;
+#ifndef MusicGetPartInstrumentNumber
+ PyMac_PRECHECK(MusicGetPartInstrumentNumber);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mc,
+ &part))
+ return NULL;
+ _rv = MusicGetPartInstrumentNumber(mc,
+ part);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicStorePartInstrument(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long part;
+ long instrumentNumber;
+#ifndef MusicStorePartInstrument
+ PyMac_PRECHECK(MusicStorePartInstrument);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&ll",
+ CmpInstObj_Convert, &mc,
+ &part,
+ &instrumentNumber))
+ return NULL;
+ _rv = MusicStorePartInstrument(mc,
+ part,
+ instrumentNumber);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicGetPartAtomicInstrument(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long part;
+ AtomicInstrument ai;
+ long flags;
+#ifndef MusicGetPartAtomicInstrument
+ PyMac_PRECHECK(MusicGetPartAtomicInstrument);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&ll",
+ CmpInstObj_Convert, &mc,
+ &part,
+ &flags))
+ return NULL;
+ _rv = MusicGetPartAtomicInstrument(mc,
+ part,
+ &ai,
+ flags);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ ResObj_New, ai);
+ return _res;
+}
+
+static PyObject *Qt_MusicSetPartAtomicInstrument(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long part;
+ AtomicInstrumentPtr aiP;
+ long flags;
+#ifndef MusicSetPartAtomicInstrument
+ PyMac_PRECHECK(MusicSetPartAtomicInstrument);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&lsl",
+ CmpInstObj_Convert, &mc,
+ &part,
+ &aiP,
+ &flags))
+ return NULL;
+ _rv = MusicSetPartAtomicInstrument(mc,
+ part,
+ aiP,
+ flags);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicGetPartKnob(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long part;
+ long knobID;
+#ifndef MusicGetPartKnob
+ PyMac_PRECHECK(MusicGetPartKnob);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&ll",
+ CmpInstObj_Convert, &mc,
+ &part,
+ &knobID))
+ return NULL;
+ _rv = MusicGetPartKnob(mc,
+ part,
+ knobID);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicSetPartKnob(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long part;
+ long knobID;
+ long knobValue;
+#ifndef MusicSetPartKnob
+ PyMac_PRECHECK(MusicSetPartKnob);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&lll",
+ CmpInstObj_Convert, &mc,
+ &part,
+ &knobID,
+ &knobValue))
+ return NULL;
+ _rv = MusicSetPartKnob(mc,
+ part,
+ knobID,
+ knobValue);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicGetKnob(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long knobID;
+#ifndef MusicGetKnob
+ PyMac_PRECHECK(MusicGetKnob);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mc,
+ &knobID))
+ return NULL;
+ _rv = MusicGetKnob(mc,
+ knobID);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicSetKnob(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long knobID;
+ long knobValue;
+#ifndef MusicSetKnob
+ PyMac_PRECHECK(MusicSetKnob);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&ll",
+ CmpInstObj_Convert, &mc,
+ &knobID,
+ &knobValue))
+ return NULL;
+ _rv = MusicSetKnob(mc,
+ knobID,
+ knobValue);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicGetPartName(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long part;
+ StringPtr name;
+#ifndef MusicGetPartName
+ PyMac_PRECHECK(MusicGetPartName);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&ls",
+ CmpInstObj_Convert, &mc,
+ &part,
+ &name))
+ return NULL;
+ _rv = MusicGetPartName(mc,
+ part,
+ name);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicSetPartName(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long part;
+ StringPtr name;
+#ifndef MusicSetPartName
+ PyMac_PRECHECK(MusicSetPartName);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&ls",
+ CmpInstObj_Convert, &mc,
+ &part,
+ &name))
+ return NULL;
+ _rv = MusicSetPartName(mc,
+ part,
+ name);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicPlayNote(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long part;
+ long pitch;
+ long velocity;
+#ifndef MusicPlayNote
+ PyMac_PRECHECK(MusicPlayNote);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&lll",
+ CmpInstObj_Convert, &mc,
+ &part,
+ &pitch,
+ &velocity))
+ return NULL;
+ _rv = MusicPlayNote(mc,
+ part,
+ pitch,
+ velocity);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicResetPart(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long part;
+#ifndef MusicResetPart
+ PyMac_PRECHECK(MusicResetPart);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mc,
+ &part))
+ return NULL;
+ _rv = MusicResetPart(mc,
+ part);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicSetPartController(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long part;
+ MusicController controllerNumber;
+ long controllerValue;
+#ifndef MusicSetPartController
+ PyMac_PRECHECK(MusicSetPartController);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&lll",
+ CmpInstObj_Convert, &mc,
+ &part,
+ &controllerNumber,
+ &controllerValue))
+ return NULL;
+ _rv = MusicSetPartController(mc,
+ part,
+ controllerNumber,
+ controllerValue);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicGetPartController(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long part;
+ MusicController controllerNumber;
+#ifndef MusicGetPartController
+ PyMac_PRECHECK(MusicGetPartController);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&ll",
+ CmpInstObj_Convert, &mc,
+ &part,
+ &controllerNumber))
+ return NULL;
+ _rv = MusicGetPartController(mc,
+ part,
+ controllerNumber);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicGetInstrumentNames(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long modifiableInstruments;
+ Handle instrumentNames;
+ Handle instrumentCategoryLasts;
+ Handle instrumentCategoryNames;
+#ifndef MusicGetInstrumentNames
+ PyMac_PRECHECK(MusicGetInstrumentNames);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mc,
+ &modifiableInstruments))
+ return NULL;
+ _rv = MusicGetInstrumentNames(mc,
+ modifiableInstruments,
+ &instrumentNames,
+ &instrumentCategoryLasts,
+ &instrumentCategoryNames);
+ _res = Py_BuildValue("lO&O&O&",
+ _rv,
+ ResObj_New, instrumentNames,
+ ResObj_New, instrumentCategoryLasts,
+ ResObj_New, instrumentCategoryNames);
+ return _res;
+}
+
+static PyObject *Qt_MusicGetDrumNames(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long modifiableInstruments;
+ Handle instrumentNumbers;
+ Handle instrumentNames;
+#ifndef MusicGetDrumNames
+ PyMac_PRECHECK(MusicGetDrumNames);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mc,
+ &modifiableInstruments))
+ return NULL;
+ _rv = MusicGetDrumNames(mc,
+ modifiableInstruments,
+ &instrumentNumbers,
+ &instrumentNames);
+ _res = Py_BuildValue("lO&O&",
+ _rv,
+ ResObj_New, instrumentNumbers,
+ ResObj_New, instrumentNames);
+ return _res;
+}
+
+static PyObject *Qt_MusicGetMasterTune(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+#ifndef MusicGetMasterTune
+ PyMac_PRECHECK(MusicGetMasterTune);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &mc))
+ return NULL;
+ _rv = MusicGetMasterTune(mc);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicSetMasterTune(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long masterTune;
+#ifndef MusicSetMasterTune
+ PyMac_PRECHECK(MusicSetMasterTune);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mc,
+ &masterTune))
+ return NULL;
+ _rv = MusicSetMasterTune(mc,
+ masterTune);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicGetDeviceConnection(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long index;
+ long id1;
+ long id2;
+#ifndef MusicGetDeviceConnection
+ PyMac_PRECHECK(MusicGetDeviceConnection);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mc,
+ &index))
+ return NULL;
+ _rv = MusicGetDeviceConnection(mc,
+ index,
+ &id1,
+ &id2);
+ _res = Py_BuildValue("lll",
+ _rv,
+ id1,
+ id2);
+ return _res;
+}
+
+static PyObject *Qt_MusicUseDeviceConnection(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long id1;
+ long id2;
+#ifndef MusicUseDeviceConnection
+ PyMac_PRECHECK(MusicUseDeviceConnection);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&ll",
+ CmpInstObj_Convert, &mc,
+ &id1,
+ &id2))
+ return NULL;
+ _rv = MusicUseDeviceConnection(mc,
+ id1,
+ id2);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicGetKnobSettingStrings(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long knobIndex;
+ long isGlobal;
+ Handle settingsNames;
+ Handle settingsCategoryLasts;
+ Handle settingsCategoryNames;
+#ifndef MusicGetKnobSettingStrings
+ PyMac_PRECHECK(MusicGetKnobSettingStrings);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&ll",
+ CmpInstObj_Convert, &mc,
+ &knobIndex,
+ &isGlobal))
+ return NULL;
+ _rv = MusicGetKnobSettingStrings(mc,
+ knobIndex,
+ isGlobal,
+ &settingsNames,
+ &settingsCategoryLasts,
+ &settingsCategoryNames);
+ _res = Py_BuildValue("lO&O&O&",
+ _rv,
+ ResObj_New, settingsNames,
+ ResObj_New, settingsCategoryLasts,
+ ResObj_New, settingsCategoryNames);
+ return _res;
+}
+
+static PyObject *Qt_MusicGetMIDIPorts(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long inputPortCount;
+ long outputPortCount;
+#ifndef MusicGetMIDIPorts
+ PyMac_PRECHECK(MusicGetMIDIPorts);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &mc))
+ return NULL;
+ _rv = MusicGetMIDIPorts(mc,
+ &inputPortCount,
+ &outputPortCount);
+ _res = Py_BuildValue("lll",
+ _rv,
+ inputPortCount,
+ outputPortCount);
+ return _res;
+}
+
+static PyObject *Qt_MusicSendMIDI(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long portIndex;
+ MusicMIDIPacket mp;
+#ifndef MusicSendMIDI
+ PyMac_PRECHECK(MusicSendMIDI);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&lO&",
+ CmpInstObj_Convert, &mc,
+ &portIndex,
+ QtMusicMIDIPacket_Convert, &mp))
+ return NULL;
+ _rv = MusicSendMIDI(mc,
+ portIndex,
+ &mp);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicSetOfflineTimeTo(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long newTimeStamp;
+#ifndef MusicSetOfflineTimeTo
+ PyMac_PRECHECK(MusicSetOfflineTimeTo);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mc,
+ &newTimeStamp))
+ return NULL;
+ _rv = MusicSetOfflineTimeTo(mc,
+ newTimeStamp);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicGetInfoText(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long selector;
+ Handle textH;
+ Handle styleH;
+#ifndef MusicGetInfoText
+ PyMac_PRECHECK(MusicGetInfoText);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mc,
+ &selector))
+ return NULL;
+ _rv = MusicGetInfoText(mc,
+ selector,
+ &textH,
+ &styleH);
+ _res = Py_BuildValue("lO&O&",
+ _rv,
+ ResObj_New, textH,
+ ResObj_New, styleH);
+ return _res;
+}
+
+static PyObject *Qt_MusicGetInstrumentInfo(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long getInstrumentInfoFlags;
+ InstrumentInfoListHandle infoListH;
+#ifndef MusicGetInstrumentInfo
+ PyMac_PRECHECK(MusicGetInstrumentInfo);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mc,
+ &getInstrumentInfoFlags))
+ return NULL;
+ _rv = MusicGetInstrumentInfo(mc,
+ getInstrumentInfoFlags,
+ &infoListH);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ ResObj_New, infoListH);
+ return _res;
+}
+
+static PyObject *Qt_MusicTask(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+#ifndef MusicTask
+ PyMac_PRECHECK(MusicTask);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &mc))
+ return NULL;
+ _rv = MusicTask(mc);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicSetPartInstrumentNumberInterruptSafe(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long part;
+ long instrumentNumber;
+#ifndef MusicSetPartInstrumentNumberInterruptSafe
+ PyMac_PRECHECK(MusicSetPartInstrumentNumberInterruptSafe);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&ll",
+ CmpInstObj_Convert, &mc,
+ &part,
+ &instrumentNumber))
+ return NULL;
+ _rv = MusicSetPartInstrumentNumberInterruptSafe(mc,
+ part,
+ instrumentNumber);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicSetPartSoundLocalization(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long part;
+ Handle data;
+#ifndef MusicSetPartSoundLocalization
+ PyMac_PRECHECK(MusicSetPartSoundLocalization);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&lO&",
+ CmpInstObj_Convert, &mc,
+ &part,
+ ResObj_Convert, &data))
+ return NULL;
+ _rv = MusicSetPartSoundLocalization(mc,
+ part,
+ data);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicGenericConfigure(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long mode;
+ long flags;
+ long baseResID;
+#ifndef MusicGenericConfigure
+ PyMac_PRECHECK(MusicGenericConfigure);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&lll",
+ CmpInstObj_Convert, &mc,
+ &mode,
+ &flags,
+ &baseResID))
+ return NULL;
+ _rv = MusicGenericConfigure(mc,
+ mode,
+ flags,
+ baseResID);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicGenericGetKnobList(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ long knobType;
+ GenericKnobDescriptionListHandle gkdlH;
+#ifndef MusicGenericGetKnobList
+ PyMac_PRECHECK(MusicGenericGetKnobList);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &mc,
+ &knobType))
+ return NULL;
+ _rv = MusicGenericGetKnobList(mc,
+ knobType,
+ &gkdlH);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ ResObj_New, gkdlH);
+ return _res;
+}
+
+static PyObject *Qt_MusicGenericSetResourceNumbers(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ Handle resourceIDH;
+#ifndef MusicGenericSetResourceNumbers
+ PyMac_PRECHECK(MusicGenericSetResourceNumbers);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ CmpInstObj_Convert, &mc,
+ ResObj_Convert, &resourceIDH))
+ return NULL;
+ _rv = MusicGenericSetResourceNumbers(mc,
+ resourceIDH);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicDerivedMIDISend(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ MusicMIDIPacket packet;
+#ifndef MusicDerivedMIDISend
+ PyMac_PRECHECK(MusicDerivedMIDISend);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ CmpInstObj_Convert, &mc,
+ QtMusicMIDIPacket_Convert, &packet))
+ return NULL;
+ _rv = MusicDerivedMIDISend(mc,
+ &packet);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicDerivedOpenResFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+#ifndef MusicDerivedOpenResFile
+ PyMac_PRECHECK(MusicDerivedOpenResFile);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &mc))
+ return NULL;
+ _rv = MusicDerivedOpenResFile(mc);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_MusicDerivedCloseResFile(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ MusicComponent mc;
+ short resRefNum;
+#ifndef MusicDerivedCloseResFile
+ PyMac_PRECHECK(MusicDerivedCloseResFile);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&h",
+ CmpInstObj_Convert, &mc,
+ &resRefNum))
+ return NULL;
+ _rv = MusicDerivedCloseResFile(mc,
+ resRefNum);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_NAUnregisterMusicDevice(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ NoteAllocator na;
+ long index;
+#ifndef NAUnregisterMusicDevice
+ PyMac_PRECHECK(NAUnregisterMusicDevice);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &na,
+ &index))
+ return NULL;
+ _rv = NAUnregisterMusicDevice(na,
+ index);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_NASaveMusicConfiguration(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ NoteAllocator na;
+#ifndef NASaveMusicConfiguration
+ PyMac_PRECHECK(NASaveMusicConfiguration);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &na))
+ return NULL;
+ _rv = NASaveMusicConfiguration(na);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_NAGetMIDIPorts(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ NoteAllocator na;
+ QTMIDIPortListHandle inputPorts;
+ QTMIDIPortListHandle outputPorts;
+#ifndef NAGetMIDIPorts
+ PyMac_PRECHECK(NAGetMIDIPorts);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &na))
+ return NULL;
+ _rv = NAGetMIDIPorts(na,
+ &inputPorts,
+ &outputPorts);
+ _res = Py_BuildValue("lO&O&",
+ _rv,
+ ResObj_New, inputPorts,
+ ResObj_New, outputPorts);
+ return _res;
+}
+
+static PyObject *Qt_NATask(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ NoteAllocator na;
+#ifndef NATask
+ PyMac_PRECHECK(NATask);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &na))
+ return NULL;
+ _rv = NATask(na);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TuneSetHeader(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TunePlayer tp;
+ unsigned long header;
+#ifndef TuneSetHeader
+ PyMac_PRECHECK(TuneSetHeader);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &tp))
+ return NULL;
+ _rv = TuneSetHeader(tp,
+ &header);
+ _res = Py_BuildValue("ll",
+ _rv,
+ header);
+ return _res;
+}
+
+static PyObject *Qt_TuneGetTimeBase(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TunePlayer tp;
+ TimeBase tb;
+#ifndef TuneGetTimeBase
+ PyMac_PRECHECK(TuneGetTimeBase);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &tp))
+ return NULL;
+ _rv = TuneGetTimeBase(tp,
+ &tb);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ TimeBaseObj_New, tb);
+ return _res;
+}
+
+static PyObject *Qt_TuneSetTimeScale(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TunePlayer tp;
+ TimeScale scale;
+#ifndef TuneSetTimeScale
+ PyMac_PRECHECK(TuneSetTimeScale);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &tp,
+ &scale))
+ return NULL;
+ _rv = TuneSetTimeScale(tp,
+ scale);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TuneGetTimeScale(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TunePlayer tp;
+ TimeScale scale;
+#ifndef TuneGetTimeScale
+ PyMac_PRECHECK(TuneGetTimeScale);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &tp))
+ return NULL;
+ _rv = TuneGetTimeScale(tp,
+ &scale);
+ _res = Py_BuildValue("ll",
+ _rv,
+ scale);
+ return _res;
+}
+
+static PyObject *Qt_TuneInstant(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TunePlayer tp;
+ unsigned long tune;
+ unsigned long tunePosition;
+#ifndef TuneInstant
+ PyMac_PRECHECK(TuneInstant);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &tp,
+ &tunePosition))
+ return NULL;
+ _rv = TuneInstant(tp,
+ &tune,
+ tunePosition);
+ _res = Py_BuildValue("ll",
+ _rv,
+ tune);
+ return _res;
+}
+
+static PyObject *Qt_TuneStop(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TunePlayer tp;
+ long stopFlags;
+#ifndef TuneStop
+ PyMac_PRECHECK(TuneStop);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &tp,
+ &stopFlags))
+ return NULL;
+ _rv = TuneStop(tp,
+ stopFlags);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TuneSetVolume(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TunePlayer tp;
+ Fixed volume;
+#ifndef TuneSetVolume
+ PyMac_PRECHECK(TuneSetVolume);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ CmpInstObj_Convert, &tp,
+ PyMac_GetFixed, &volume))
+ return NULL;
+ _rv = TuneSetVolume(tp,
+ volume);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TuneGetVolume(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TunePlayer tp;
+#ifndef TuneGetVolume
+ PyMac_PRECHECK(TuneGetVolume);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &tp))
+ return NULL;
+ _rv = TuneGetVolume(tp);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TunePreroll(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TunePlayer tp;
+#ifndef TunePreroll
+ PyMac_PRECHECK(TunePreroll);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &tp))
+ return NULL;
+ _rv = TunePreroll(tp);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TuneUnroll(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TunePlayer tp;
+#ifndef TuneUnroll
+ PyMac_PRECHECK(TuneUnroll);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &tp))
+ return NULL;
+ _rv = TuneUnroll(tp);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TuneSetPartTranspose(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TunePlayer tp;
+ unsigned long part;
+ long transpose;
+ long velocityShift;
+#ifndef TuneSetPartTranspose
+ PyMac_PRECHECK(TuneSetPartTranspose);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&lll",
+ CmpInstObj_Convert, &tp,
+ &part,
+ &transpose,
+ &velocityShift))
+ return NULL;
+ _rv = TuneSetPartTranspose(tp,
+ part,
+ transpose,
+ velocityShift);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TuneGetNoteAllocator(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ NoteAllocator _rv;
+ TunePlayer tp;
+#ifndef TuneGetNoteAllocator
+ PyMac_PRECHECK(TuneGetNoteAllocator);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &tp))
+ return NULL;
+ _rv = TuneGetNoteAllocator(tp);
+ _res = Py_BuildValue("O&",
+ CmpInstObj_New, _rv);
+ return _res;
+}
+
+static PyObject *Qt_TuneSetSofter(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TunePlayer tp;
+ long softer;
+#ifndef TuneSetSofter
+ PyMac_PRECHECK(TuneSetSofter);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &tp,
+ &softer))
+ return NULL;
+ _rv = TuneSetSofter(tp,
+ softer);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TuneTask(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TunePlayer tp;
+#ifndef TuneTask
+ PyMac_PRECHECK(TuneTask);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CmpInstObj_Convert, &tp))
+ return NULL;
+ _rv = TuneTask(tp);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TuneSetBalance(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TunePlayer tp;
+ long balance;
+#ifndef TuneSetBalance
+ PyMac_PRECHECK(TuneSetBalance);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &tp,
+ &balance))
+ return NULL;
+ _rv = TuneSetBalance(tp,
+ balance);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TuneSetSoundLocalization(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TunePlayer tp;
+ Handle data;
+#ifndef TuneSetSoundLocalization
+ PyMac_PRECHECK(TuneSetSoundLocalization);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ CmpInstObj_Convert, &tp,
+ ResObj_Convert, &data))
+ return NULL;
+ _rv = TuneSetSoundLocalization(tp,
+ data);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TuneSetHeaderWithSize(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TunePlayer tp;
+ unsigned long header;
+ unsigned long size;
+#ifndef TuneSetHeaderWithSize
+ PyMac_PRECHECK(TuneSetHeaderWithSize);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &tp,
+ &size))
+ return NULL;
+ _rv = TuneSetHeaderWithSize(tp,
+ &header,
+ size);
+ _res = Py_BuildValue("ll",
+ _rv,
+ header);
+ return _res;
+}
+
+static PyObject *Qt_TuneSetPartMix(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TunePlayer tp;
+ unsigned long partNumber;
+ long volume;
+ long balance;
+ long mixFlags;
+#ifndef TuneSetPartMix
+ PyMac_PRECHECK(TuneSetPartMix);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&llll",
+ CmpInstObj_Convert, &tp,
+ &partNumber,
+ &volume,
+ &balance,
+ &mixFlags))
+ return NULL;
+ _rv = TuneSetPartMix(tp,
+ partNumber,
+ volume,
+ balance,
+ mixFlags);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
+static PyObject *Qt_TuneGetPartMix(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ComponentResult _rv;
+ TunePlayer tp;
+ unsigned long partNumber;
+ long volumeOut;
+ long balanceOut;
+ long mixFlagsOut;
+#ifndef TuneGetPartMix
+ PyMac_PRECHECK(TuneGetPartMix);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CmpInstObj_Convert, &tp,
+ &partNumber))
+ return NULL;
+ _rv = TuneGetPartMix(tp,
+ partNumber,
+ &volumeOut,
+ &balanceOut,
+ &mixFlagsOut);
+ _res = Py_BuildValue("llll",
+ _rv,
+ volumeOut,
+ balanceOut,
+ mixFlagsOut);
+ return _res;
+}
+
static PyObject *Qt_AlignWindow(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
@@ -26415,6 +27846,134 @@
PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, IdleManager pim)")},
{"MediaGSetIdleManager", (PyCFunction)Qt_MediaGSetIdleManager, 1,
PyDoc_STR("(MediaHandler mh, IdleManager im) -> (ComponentResult _rv)")},
+ {"QTMIDIGetMIDIPorts", (PyCFunction)Qt_QTMIDIGetMIDIPorts, 1,
+ PyDoc_STR("(QTMIDIComponent ci) -> (ComponentResult _rv, QTMIDIPortListHandle inputPorts, QTMIDIPortListHandle outputPorts)")},
+ {"QTMIDIUseSendPort", (PyCFunction)Qt_QTMIDIUseSendPort, 1,
+ PyDoc_STR("(QTMIDIComponent ci, long portIndex, long inUse) -> (ComponentResult _rv)")},
+ {"QTMIDISendMIDI", (PyCFunction)Qt_QTMIDISendMIDI, 1,
+ PyDoc_STR("(QTMIDIComponent ci, long portIndex, MusicMIDIPacket mp) -> (ComponentResult _rv)")},
+ {"MusicGetPart", (PyCFunction)Qt_MusicGetPart, 1,
+ PyDoc_STR("(MusicComponent mc, long part) -> (ComponentResult _rv, long midiChannel, long polyphony)")},
+ {"MusicSetPart", (PyCFunction)Qt_MusicSetPart, 1,
+ PyDoc_STR("(MusicComponent mc, long part, long midiChannel, long polyphony) -> (ComponentResult _rv)")},
+ {"MusicSetPartInstrumentNumber", (PyCFunction)Qt_MusicSetPartInstrumentNumber, 1,
+ PyDoc_STR("(MusicComponent mc, long part, long instrumentNumber) -> (ComponentResult _rv)")},
+ {"MusicGetPartInstrumentNumber", (PyCFunction)Qt_MusicGetPartInstrumentNumber, 1,
+ PyDoc_STR("(MusicComponent mc, long part) -> (ComponentResult _rv)")},
+ {"MusicStorePartInstrument", (PyCFunction)Qt_MusicStorePartInstrument, 1,
+ PyDoc_STR("(MusicComponent mc, long part, long instrumentNumber) -> (ComponentResult _rv)")},
+ {"MusicGetPartAtomicInstrument", (PyCFunction)Qt_MusicGetPartAtomicInstrument, 1,
+ PyDoc_STR("(MusicComponent mc, long part, long flags) -> (ComponentResult _rv, AtomicInstrument ai)")},
+ {"MusicSetPartAtomicInstrument", (PyCFunction)Qt_MusicSetPartAtomicInstrument, 1,
+ PyDoc_STR("(MusicComponent mc, long part, AtomicInstrumentPtr aiP, long flags) -> (ComponentResult _rv)")},
+ {"MusicGetPartKnob", (PyCFunction)Qt_MusicGetPartKnob, 1,
+ PyDoc_STR("(MusicComponent mc, long part, long knobID) -> (ComponentResult _rv)")},
+ {"MusicSetPartKnob", (PyCFunction)Qt_MusicSetPartKnob, 1,
+ PyDoc_STR("(MusicComponent mc, long part, long knobID, long knobValue) -> (ComponentResult _rv)")},
+ {"MusicGetKnob", (PyCFunction)Qt_MusicGetKnob, 1,
+ PyDoc_STR("(MusicComponent mc, long knobID) -> (ComponentResult _rv)")},
+ {"MusicSetKnob", (PyCFunction)Qt_MusicSetKnob, 1,
+ PyDoc_STR("(MusicComponent mc, long knobID, long knobValue) -> (ComponentResult _rv)")},
+ {"MusicGetPartName", (PyCFunction)Qt_MusicGetPartName, 1,
+ PyDoc_STR("(MusicComponent mc, long part, StringPtr name) -> (ComponentResult _rv)")},
+ {"MusicSetPartName", (PyCFunction)Qt_MusicSetPartName, 1,
+ PyDoc_STR("(MusicComponent mc, long part, StringPtr name) -> (ComponentResult _rv)")},
+ {"MusicPlayNote", (PyCFunction)Qt_MusicPlayNote, 1,
+ PyDoc_STR("(MusicComponent mc, long part, long pitch, long velocity) -> (ComponentResult _rv)")},
+ {"MusicResetPart", (PyCFunction)Qt_MusicResetPart, 1,
+ PyDoc_STR("(MusicComponent mc, long part) -> (ComponentResult _rv)")},
+ {"MusicSetPartController", (PyCFunction)Qt_MusicSetPartController, 1,
+ PyDoc_STR("(MusicComponent mc, long part, MusicController controllerNumber, long controllerValue) -> (ComponentResult _rv)")},
+ {"MusicGetPartController", (PyCFunction)Qt_MusicGetPartController, 1,
+ PyDoc_STR("(MusicComponent mc, long part, MusicController controllerNumber) -> (ComponentResult _rv)")},
+ {"MusicGetInstrumentNames", (PyCFunction)Qt_MusicGetInstrumentNames, 1,
+ PyDoc_STR("(MusicComponent mc, long modifiableInstruments) -> (ComponentResult _rv, Handle instrumentNames, Handle instrumentCategoryLasts, Handle instrumentCategoryNames)")},
+ {"MusicGetDrumNames", (PyCFunction)Qt_MusicGetDrumNames, 1,
+ PyDoc_STR("(MusicComponent mc, long modifiableInstruments) -> (ComponentResult _rv, Handle instrumentNumbers, Handle instrumentNames)")},
+ {"MusicGetMasterTune", (PyCFunction)Qt_MusicGetMasterTune, 1,
+ PyDoc_STR("(MusicComponent mc) -> (ComponentResult _rv)")},
+ {"MusicSetMasterTune", (PyCFunction)Qt_MusicSetMasterTune, 1,
+ PyDoc_STR("(MusicComponent mc, long masterTune) -> (ComponentResult _rv)")},
+ {"MusicGetDeviceConnection", (PyCFunction)Qt_MusicGetDeviceConnection, 1,
+ PyDoc_STR("(MusicComponent mc, long index) -> (ComponentResult _rv, long id1, long id2)")},
+ {"MusicUseDeviceConnection", (PyCFunction)Qt_MusicUseDeviceConnection, 1,
+ PyDoc_STR("(MusicComponent mc, long id1, long id2) -> (ComponentResult _rv)")},
+ {"MusicGetKnobSettingStrings", (PyCFunction)Qt_MusicGetKnobSettingStrings, 1,
+ PyDoc_STR("(MusicComponent mc, long knobIndex, long isGlobal) -> (ComponentResult _rv, Handle settingsNames, Handle settingsCategoryLasts, Handle settingsCategoryNames)")},
+ {"MusicGetMIDIPorts", (PyCFunction)Qt_MusicGetMIDIPorts, 1,
+ PyDoc_STR("(MusicComponent mc) -> (ComponentResult _rv, long inputPortCount, long outputPortCount)")},
+ {"MusicSendMIDI", (PyCFunction)Qt_MusicSendMIDI, 1,
+ PyDoc_STR("(MusicComponent mc, long portIndex, MusicMIDIPacket mp) -> (ComponentResult _rv)")},
+ {"MusicSetOfflineTimeTo", (PyCFunction)Qt_MusicSetOfflineTimeTo, 1,
+ PyDoc_STR("(MusicComponent mc, long newTimeStamp) -> (ComponentResult _rv)")},
+ {"MusicGetInfoText", (PyCFunction)Qt_MusicGetInfoText, 1,
+ PyDoc_STR("(MusicComponent mc, long selector) -> (ComponentResult _rv, Handle textH, Handle styleH)")},
+ {"MusicGetInstrumentInfo", (PyCFunction)Qt_MusicGetInstrumentInfo, 1,
+ PyDoc_STR("(MusicComponent mc, long getInstrumentInfoFlags) -> (ComponentResult _rv, InstrumentInfoListHandle infoListH)")},
+ {"MusicTask", (PyCFunction)Qt_MusicTask, 1,
+ PyDoc_STR("(MusicComponent mc) -> (ComponentResult _rv)")},
+ {"MusicSetPartInstrumentNumberInterruptSafe", (PyCFunction)Qt_MusicSetPartInstrumentNumberInterruptSafe, 1,
+ PyDoc_STR("(MusicComponent mc, long part, long instrumentNumber) -> (ComponentResult _rv)")},
+ {"MusicSetPartSoundLocalization", (PyCFunction)Qt_MusicSetPartSoundLocalization, 1,
+ PyDoc_STR("(MusicComponent mc, long part, Handle data) -> (ComponentResult _rv)")},
+ {"MusicGenericConfigure", (PyCFunction)Qt_MusicGenericConfigure, 1,
+ PyDoc_STR("(MusicComponent mc, long mode, long flags, long baseResID) -> (ComponentResult _rv)")},
+ {"MusicGenericGetKnobList", (PyCFunction)Qt_MusicGenericGetKnobList, 1,
+ PyDoc_STR("(MusicComponent mc, long knobType) -> (ComponentResult _rv, GenericKnobDescriptionListHandle gkdlH)")},
+ {"MusicGenericSetResourceNumbers", (PyCFunction)Qt_MusicGenericSetResourceNumbers, 1,
+ PyDoc_STR("(MusicComponent mc, Handle resourceIDH) -> (ComponentResult _rv)")},
+ {"MusicDerivedMIDISend", (PyCFunction)Qt_MusicDerivedMIDISend, 1,
+ PyDoc_STR("(MusicComponent mc, MusicMIDIPacket packet) -> (ComponentResult _rv)")},
+ {"MusicDerivedOpenResFile", (PyCFunction)Qt_MusicDerivedOpenResFile, 1,
+ PyDoc_STR("(MusicComponent mc) -> (ComponentResult _rv)")},
+ {"MusicDerivedCloseResFile", (PyCFunction)Qt_MusicDerivedCloseResFile, 1,
+ PyDoc_STR("(MusicComponent mc, short resRefNum) -> (ComponentResult _rv)")},
+ {"NAUnregisterMusicDevice", (PyCFunction)Qt_NAUnregisterMusicDevice, 1,
+ PyDoc_STR("(NoteAllocator na, long index) -> (ComponentResult _rv)")},
+ {"NASaveMusicConfiguration", (PyCFunction)Qt_NASaveMusicConfiguration, 1,
+ PyDoc_STR("(NoteAllocator na) -> (ComponentResult _rv)")},
+ {"NAGetMIDIPorts", (PyCFunction)Qt_NAGetMIDIPorts, 1,
+ PyDoc_STR("(NoteAllocator na) -> (ComponentResult _rv, QTMIDIPortListHandle inputPorts, QTMIDIPortListHandle outputPorts)")},
+ {"NATask", (PyCFunction)Qt_NATask, 1,
+ PyDoc_STR("(NoteAllocator na) -> (ComponentResult _rv)")},
+ {"TuneSetHeader", (PyCFunction)Qt_TuneSetHeader, 1,
+ PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv, unsigned long header)")},
+ {"TuneGetTimeBase", (PyCFunction)Qt_TuneGetTimeBase, 1,
+ PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv, TimeBase tb)")},
+ {"TuneSetTimeScale", (PyCFunction)Qt_TuneSetTimeScale, 1,
+ PyDoc_STR("(TunePlayer tp, TimeScale scale) -> (ComponentResult _rv)")},
+ {"TuneGetTimeScale", (PyCFunction)Qt_TuneGetTimeScale, 1,
+ PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv, TimeScale scale)")},
+ {"TuneInstant", (PyCFunction)Qt_TuneInstant, 1,
+ PyDoc_STR("(TunePlayer tp, unsigned long tunePosition) -> (ComponentResult _rv, unsigned long tune)")},
+ {"TuneStop", (PyCFunction)Qt_TuneStop, 1,
+ PyDoc_STR("(TunePlayer tp, long stopFlags) -> (ComponentResult _rv)")},
+ {"TuneSetVolume", (PyCFunction)Qt_TuneSetVolume, 1,
+ PyDoc_STR("(TunePlayer tp, Fixed volume) -> (ComponentResult _rv)")},
+ {"TuneGetVolume", (PyCFunction)Qt_TuneGetVolume, 1,
+ PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv)")},
+ {"TunePreroll", (PyCFunction)Qt_TunePreroll, 1,
+ PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv)")},
+ {"TuneUnroll", (PyCFunction)Qt_TuneUnroll, 1,
+ PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv)")},
+ {"TuneSetPartTranspose", (PyCFunction)Qt_TuneSetPartTranspose, 1,
+ PyDoc_STR("(TunePlayer tp, unsigned long part, long transpose, long velocityShift) -> (ComponentResult _rv)")},
+ {"TuneGetNoteAllocator", (PyCFunction)Qt_TuneGetNoteAllocator, 1,
+ PyDoc_STR("(TunePlayer tp) -> (NoteAllocator _rv)")},
+ {"TuneSetSofter", (PyCFunction)Qt_TuneSetSofter, 1,
+ PyDoc_STR("(TunePlayer tp, long softer) -> (ComponentResult _rv)")},
+ {"TuneTask", (PyCFunction)Qt_TuneTask, 1,
+ PyDoc_STR("(TunePlayer tp) -> (ComponentResult _rv)")},
+ {"TuneSetBalance", (PyCFunction)Qt_TuneSetBalance, 1,
+ PyDoc_STR("(TunePlayer tp, long balance) -> (ComponentResult _rv)")},
+ {"TuneSetSoundLocalization", (PyCFunction)Qt_TuneSetSoundLocalization, 1,
+ PyDoc_STR("(TunePlayer tp, Handle data) -> (ComponentResult _rv)")},
+ {"TuneSetHeaderWithSize", (PyCFunction)Qt_TuneSetHeaderWithSize, 1,
+ PyDoc_STR("(TunePlayer tp, unsigned long size) -> (ComponentResult _rv, unsigned long header)")},
+ {"TuneSetPartMix", (PyCFunction)Qt_TuneSetPartMix, 1,
+ PyDoc_STR("(TunePlayer tp, unsigned long partNumber, long volume, long balance, long mixFlags) -> (ComponentResult _rv)")},
+ {"TuneGetPartMix", (PyCFunction)Qt_TuneGetPartMix, 1,
+ PyDoc_STR("(TunePlayer tp, unsigned long partNumber) -> (ComponentResult _rv, long volumeOut, long balanceOut, long mixFlagsOut)")},
{"AlignWindow", (PyCFunction)Qt_AlignWindow, 1,
PyDoc_STR("(WindowPtr wp, Boolean front) -> None")},
{"DragAlignedWindow", (PyCFunction)Qt_DragAlignedWindow, 1,
diff --git a/Mac/Modules/qt/qtscan.py b/Mac/Modules/qt/qtscan.py
index b32fc6b..175a220 100644
--- a/Mac/Modules/qt/qtscan.py
+++ b/Mac/Modules/qt/qtscan.py
@@ -13,7 +13,11 @@
"ImageCompression.h",
"QuickTimeComponents.h",
# "ImageCodec.h" -- seems not too useful, and difficult.
- "MediaHandlers.h"
+ "MediaHandlers.h",
+# "QTML.h", -- Windows only, needs separate module
+# "QuickTimeStreaming.h", -- Difficult
+# "QTStreamingComponents.h", -- Needs QTStreaming
+ "QuickTimeMusic.h",
)
OBJECTS = ("Movie", "Track", "Media", "UserData", "TimeBase", "MovieController",
"IdleManager", "SGOutput")
@@ -47,6 +51,24 @@
def writeinitialdefs(self):
self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n")
self.defsfile.write("xmlIdentifierUnrecognized = -1\n")
+ self.defsfile.write("kControllerMinimum = -0xf777\n")
+ self.defsfile.write("notImplementedMusicOSErr = -2071\n")
+ self.defsfile.write("cantSendToSynthesizerOSErr = -2072\n")
+ self.defsfile.write("cantReceiveFromSynthesizerOSErr = -2073\n")
+ self.defsfile.write("illegalVoiceAllocationOSErr = -2074\n")
+ self.defsfile.write("illegalPartOSErr = -2075\n")
+ self.defsfile.write("illegalChannelOSErr = -2076\n")
+ self.defsfile.write("illegalKnobOSErr = -2077\n")
+ self.defsfile.write("illegalKnobValueOSErr = -2078\n")
+ self.defsfile.write("illegalInstrumentOSErr = -2079\n")
+ self.defsfile.write("illegalControllerOSErr = -2080\n")
+ self.defsfile.write("midiManagerAbsentOSErr = -2081\n")
+ self.defsfile.write("synthesizerNotRespondingOSErr = -2082\n")
+ self.defsfile.write("synthesizerOSErr = -2083\n")
+ self.defsfile.write("illegalNoteChannelOSErr = -2084\n")
+ self.defsfile.write("noteChannelNotAllocatedOSErr = -2085\n")
+ self.defsfile.write("tunePlayerFullOSErr = -2086\n")
+ self.defsfile.write("tuneParseOSErr = -2087\n")
def makeblacklistnames(self):
return [
@@ -100,6 +122,15 @@
# MediaHandlers
"MediaMakeMediaTimeTable", # just lazy
"MediaGetSampleDataPointer", # funny output pointer
+
+ # QuickTimeMusic
+ "kControllerMinimum",
+ # These are artefacts of a macro definition
+ "ulen",
+ "_ext",
+ "x",
+ "w1",
+ "w2",
]
def makeblacklisttypes(self):
@@ -223,6 +254,23 @@
"GetMovieCompleteParams", # Immense struct
"LevelMeterInfoPtr", # Lazy. Also: can be an output parameter!!
"MediaEQSpectrumBandsRecordPtr", # ditto
+
+ # From QuickTimeMusic
+ "MusicMIDISendUPP",
+ "MusicOfflineDataUPP",
+ "TuneCallBackUPP",
+ "TunePlayCallBackUPP",
+ "GCPart", # Struct with lots of fields
+ "GCPart_ptr",
+ "GenericKnobDescription", # Struct with lots of fields
+ "KnobDescription", # Struct with lots of fields
+ "InstrumentAboutInfo", # Struct, not too difficult
+ "NoteChannel", # XXXX Lazy. Could be opaque, I think
+ "NoteRequest", # XXXX Lazy. Not-too-difficult struct
+ "SynthesizerConnections", # Struct with lots of fields
+ "SynthesizerDescription", # Struct with lots of fields
+ "TuneStatus", # Struct with lots of fields
+
]
def makerepairinstructions(self):
@@ -254,6 +302,10 @@
([('char_ptr', '*', 'InMode')], [('stringptr', '*', 'InMode')]),
([('FSSpecPtr', '*', 'InMode')], [('FSSpec_ptr', '*', 'InMode')]),
([('unsigned_char', 'swfVersion', 'OutMode')], [('UInt8', 'swfVersion', 'OutMode')]),
+
+ # It seems MusicMIDIPacket if never flagged with const but always used
+ # for sending only. If that ever changes this needs to be fixed.
+ ([('MusicMIDIPacket', '*', 'OutMode')], [('MusicMIDIPacket_ptr', '*', 'InMode')]),
]
if __name__ == "__main__":
diff --git a/Mac/Modules/qt/qtsupport.py b/Mac/Modules/qt/qtsupport.py
index c2dd024..098d30d 100644
--- a/Mac/Modules/qt/qtsupport.py
+++ b/Mac/Modules/qt/qtsupport.py
@@ -88,6 +88,16 @@
return 1;
}
+static int
+QtMusicMIDIPacket_Convert(PyObject *v, MusicMIDIPacket *p_itself)
+{
+ int dummy;
+
+ if( !PyArg_ParseTuple(v, "hls#", &p_itself->length, &p_itself->reserved, p_itself->data, dummy) )
+ return 0;
+ return 1;
+}
+
"""
@@ -143,6 +153,10 @@
MediaHandler = OpaqueByValueType('MediaHandler', 'CmpInstObj')
DataHandler = OpaqueByValueType('DataHandler', 'CmpInstObj')
SGChannel = OpaqueByValueType('SGChannel', 'CmpInstObj')
+TunePlayer = OpaqueByValueType('TunePlayer', 'CmpInstObj')
+MusicComponent = OpaqueByValueType('MusicComponent', 'CmpInstObj')
+NoteAllocator = OpaqueByValueType('NoteAllocator', 'CmpInstObj')
+QTMIDIComponent = OpaqueByValueType('QTMIDIComponent', 'CmpInstObj')
ConstFSSpecPtr = FSSpec_ptr
GrafPtr = OpaqueByValueType("GrafPtr", "GrafObj")
@@ -164,6 +178,9 @@
VDCompressionListHandle = OpaqueByValueType("VDCompressionListHandle", "ResObj")
TimeCodeDescriptionHandle = OpaqueByValueType("TimeCodeDescriptionHandle", "ResObj")
DataHFileTypeOrderingHandle = OpaqueByValueType("DataHFileTypeOrderingHandle", "ResObj")
+QTMIDIPortListHandle = OpaqueByValueType("QTMIDIPortListHandle", "ResObj")
+GenericKnobDescriptionListHandle = OpaqueByValueType("GenericKnobDescriptionListHandle", "ResObj")
+InstrumentInfoListHandle = OpaqueByValueType("InstrumentInfoListHandle", "ResObj")
# Silly Apple, passing an OStype by reference...
OSType_ptr = OpaqueType("OSType", "PyMac_BuildOSType", "PyMac_GetOSType")
# And even sillier: passing floats by address
@@ -173,6 +190,8 @@
RGBColor_ptr = RGBColor
TimeRecord = OpaqueType("TimeRecord", "QtTimeRecord")
TimeRecord_ptr = TimeRecord
+MusicMIDIPacket = OpaqueType("MusicMIDIPacket", "QtMusicMIDIPacket")
+MusicMIDIPacket_ptr = MusicMIDIPacket
# Non-opaque types, mostly integer-ish
TimeValue = Type("TimeValue", "l")
@@ -200,11 +219,16 @@
GWorldPtr = OpaqueByValueType("GWorldPtr", "GWorldObj")
QTFloatSingle = Type("QTFloatSingle", "f")
CodecQ = Type("CodecQ", "l")
+MusicController = Type("MusicController", "l")
# Could-not-be-bothered-types (NewMovieFromFile)
dummyshortptr = FakeType('(short *)0')
dummyStringPtr = FakeType('(StringPtr)0')
+# Not-quite-sure-this-is-okay types
+AtomicInstrument = OpaqueByValueType("AtomicInstrument", "ResObj")
+AtomicInstrumentPtr = InputOnlyType("AtomicInstrumentPtr", "s")
+
# XXXX Need to override output_tp_newBody() to allow for None initializer.
class QtGlobalObjectDefinition(PEP253Mixin, GlobalObjectDefinition):
def outputCheckNewArg(self):