Regenerated with PyDoc_STR() around docstrings.

1 files changed, 405 insertions, 405 deletions

diff --git a/Mac/Modules/qt/_Qtmodule.c b/Mac/Modules/qt/_Qtmodule.c
index 1f6dbbb..687aaee 100644
--- a/Mac/Modules/qt/_Qtmodule.c
+++ b/Mac/Modules/qt/_Qtmodule.c
@@ -996,97 +996,97 @@ static PyObject *MovieCtlObj_MCTrimMovieSegment(MovieControllerObject *_self, Py
 
 static PyMethodDef MovieCtlObj_methods[] = {
 	{"MCSetMovie", (PyCFunction)MovieCtlObj_MCSetMovie, 1,
-	 "(Movie theMovie, WindowPtr movieWindow, Point where) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Movie theMovie, WindowPtr movieWindow, Point where) -> (ComponentResult _rv)")},
 	{"MCGetIndMovie", (PyCFunction)MovieCtlObj_MCGetIndMovie, 1,
-	 "(short index) -> (Movie _rv)"},
+	 PyDoc_STR("(short index) -> (Movie _rv)")},
 	{"MCRemoveAllMovies", (PyCFunction)MovieCtlObj_MCRemoveAllMovies, 1,
-	 "() -> (ComponentResult _rv)"},
+	 PyDoc_STR("() -> (ComponentResult _rv)")},
 	{"MCRemoveAMovie", (PyCFunction)MovieCtlObj_MCRemoveAMovie, 1,
-	 "(Movie m) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Movie m) -> (ComponentResult _rv)")},
 	{"MCRemoveMovie", (PyCFunction)MovieCtlObj_MCRemoveMovie, 1,
-	 "() -> (ComponentResult _rv)"},
+	 PyDoc_STR("() -> (ComponentResult _rv)")},
 	{"MCIsPlayerEvent", (PyCFunction)MovieCtlObj_MCIsPlayerEvent, 1,
-	 "(EventRecord e) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(EventRecord e) -> (ComponentResult _rv)")},
 	{"MCDoAction", (PyCFunction)MovieCtlObj_MCDoAction, 1,
-	 "(short action, void * params) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(short action, void * params) -> (ComponentResult _rv)")},
 	{"MCSetControllerAttached", (PyCFunction)MovieCtlObj_MCSetControllerAttached, 1,
-	 "(Boolean attach) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Boolean attach) -> (ComponentResult _rv)")},
 	{"MCIsControllerAttached", (PyCFunction)MovieCtlObj_MCIsControllerAttached, 1,
-	 "() -> (ComponentResult _rv)"},
+	 PyDoc_STR("() -> (ComponentResult _rv)")},
 	{"MCSetControllerPort", (PyCFunction)MovieCtlObj_MCSetControllerPort, 1,
-	 "(CGrafPtr gp) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(CGrafPtr gp) -> (ComponentResult _rv)")},
 	{"MCGetControllerPort", (PyCFunction)MovieCtlObj_MCGetControllerPort, 1,
-	 "() -> (CGrafPtr _rv)"},
+	 PyDoc_STR("() -> (CGrafPtr _rv)")},
 	{"MCSetVisible", (PyCFunction)MovieCtlObj_MCSetVisible, 1,
-	 "(Boolean visible) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Boolean visible) -> (ComponentResult _rv)")},
 	{"MCGetVisible", (PyCFunction)MovieCtlObj_MCGetVisible, 1,
-	 "() -> (ComponentResult _rv)"},
+	 PyDoc_STR("() -> (ComponentResult _rv)")},
 	{"MCGetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRect, 1,
-	 "() -> (ComponentResult _rv, Rect bounds)"},
+	 PyDoc_STR("() -> (ComponentResult _rv, Rect bounds)")},
 	{"MCSetControllerBoundsRect", (PyCFunction)MovieCtlObj_MCSetControllerBoundsRect, 1,
-	 "(Rect bounds) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Rect bounds) -> (ComponentResult _rv)")},
 	{"MCGetControllerBoundsRgn", (PyCFunction)MovieCtlObj_MCGetControllerBoundsRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"MCGetWindowRgn", (PyCFunction)MovieCtlObj_MCGetWindowRgn, 1,
-	 "(WindowPtr w) -> (RgnHandle _rv)"},
+	 PyDoc_STR("(WindowPtr w) -> (RgnHandle _rv)")},
 	{"MCMovieChanged", (PyCFunction)MovieCtlObj_MCMovieChanged, 1,
-	 "(Movie m) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Movie m) -> (ComponentResult _rv)")},
 	{"MCSetDuration", (PyCFunction)MovieCtlObj_MCSetDuration, 1,
-	 "(TimeValue duration) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(TimeValue duration) -> (ComponentResult _rv)")},
 	{"MCGetCurrentTime", (PyCFunction)MovieCtlObj_MCGetCurrentTime, 1,
-	 "() -> (TimeValue _rv, TimeScale scale)"},
+	 PyDoc_STR("() -> (TimeValue _rv, TimeScale scale)")},
 	{"MCNewAttachedController", (PyCFunction)MovieCtlObj_MCNewAttachedController, 1,
-	 "(Movie theMovie, WindowPtr w, Point where) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Movie theMovie, WindowPtr w, Point where) -> (ComponentResult _rv)")},
 	{"MCDraw", (PyCFunction)MovieCtlObj_MCDraw, 1,
-	 "(WindowPtr w) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(WindowPtr w) -> (ComponentResult _rv)")},
 	{"MCActivate", (PyCFunction)MovieCtlObj_MCActivate, 1,
-	 "(WindowPtr w, Boolean activate) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(WindowPtr w, Boolean activate) -> (ComponentResult _rv)")},
 	{"MCIdle", (PyCFunction)MovieCtlObj_MCIdle, 1,
-	 "() -> (ComponentResult _rv)"},
+	 PyDoc_STR("() -> (ComponentResult _rv)")},
 	{"MCKey", (PyCFunction)MovieCtlObj_MCKey, 1,
-	 "(SInt8 key, long modifiers) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(SInt8 key, long modifiers) -> (ComponentResult _rv)")},
 	{"MCClick", (PyCFunction)MovieCtlObj_MCClick, 1,
-	 "(WindowPtr w, Point where, long when, long modifiers) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(WindowPtr w, Point where, long when, long modifiers) -> (ComponentResult _rv)")},
 	{"MCEnableEditing", (PyCFunction)MovieCtlObj_MCEnableEditing, 1,
-	 "(Boolean enabled) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Boolean enabled) -> (ComponentResult _rv)")},
 	{"MCIsEditingEnabled", (PyCFunction)MovieCtlObj_MCIsEditingEnabled, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"MCCopy", (PyCFunction)MovieCtlObj_MCCopy, 1,
-	 "() -> (Movie _rv)"},
+	 PyDoc_STR("() -> (Movie _rv)")},
 	{"MCCut", (PyCFunction)MovieCtlObj_MCCut, 1,
-	 "() -> (Movie _rv)"},
+	 PyDoc_STR("() -> (Movie _rv)")},
 	{"MCPaste", (PyCFunction)MovieCtlObj_MCPaste, 1,
-	 "(Movie srcMovie) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Movie srcMovie) -> (ComponentResult _rv)")},
 	{"MCClear", (PyCFunction)MovieCtlObj_MCClear, 1,
-	 "() -> (ComponentResult _rv)"},
+	 PyDoc_STR("() -> (ComponentResult _rv)")},
 	{"MCUndo", (PyCFunction)MovieCtlObj_MCUndo, 1,
-	 "() -> (ComponentResult _rv)"},
+	 PyDoc_STR("() -> (ComponentResult _rv)")},
 	{"MCPositionController", (PyCFunction)MovieCtlObj_MCPositionController, 1,
-	 "(Rect movieRect, Rect controllerRect, long someFlags) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Rect movieRect, Rect controllerRect, long someFlags) -> (ComponentResult _rv)")},
 	{"MCGetControllerInfo", (PyCFunction)MovieCtlObj_MCGetControllerInfo, 1,
-	 "() -> (ComponentResult _rv, long someFlags)"},
+	 PyDoc_STR("() -> (ComponentResult _rv, long someFlags)")},
 	{"MCSetClip", (PyCFunction)MovieCtlObj_MCSetClip, 1,
-	 "(RgnHandle theClip, RgnHandle movieClip) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(RgnHandle theClip, RgnHandle movieClip) -> (ComponentResult _rv)")},
 	{"MCGetClip", (PyCFunction)MovieCtlObj_MCGetClip, 1,
-	 "() -> (ComponentResult _rv, RgnHandle theClip, RgnHandle movieClip)"},
+	 PyDoc_STR("() -> (ComponentResult _rv, RgnHandle theClip, RgnHandle movieClip)")},
 	{"MCDrawBadge", (PyCFunction)MovieCtlObj_MCDrawBadge, 1,
-	 "(RgnHandle movieRgn) -> (ComponentResult _rv, RgnHandle badgeRgn)"},
+	 PyDoc_STR("(RgnHandle movieRgn) -> (ComponentResult _rv, RgnHandle badgeRgn)")},
 	{"MCSetUpEditMenu", (PyCFunction)MovieCtlObj_MCSetUpEditMenu, 1,
-	 "(long modifiers, MenuHandle mh) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(long modifiers, MenuHandle mh) -> (ComponentResult _rv)")},
 	{"MCGetMenuString", (PyCFunction)MovieCtlObj_MCGetMenuString, 1,
-	 "(long modifiers, short item, Str255 aString) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(long modifiers, short item, Str255 aString) -> (ComponentResult _rv)")},
 	{"MCPtInController", (PyCFunction)MovieCtlObj_MCPtInController, 1,
-	 "(Point thePt) -> (ComponentResult _rv, Boolean inController)"},
+	 PyDoc_STR("(Point thePt) -> (ComponentResult _rv, Boolean inController)")},
 	{"MCInvalidate", (PyCFunction)MovieCtlObj_MCInvalidate, 1,
-	 "(WindowPtr w, RgnHandle invalidRgn) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(WindowPtr w, RgnHandle invalidRgn) -> (ComponentResult _rv)")},
 	{"MCAdjustCursor", (PyCFunction)MovieCtlObj_MCAdjustCursor, 1,
-	 "(WindowPtr w, Point where, long modifiers) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(WindowPtr w, Point where, long modifiers) -> (ComponentResult _rv)")},
 	{"MCGetInterfaceElement", (PyCFunction)MovieCtlObj_MCGetInterfaceElement, 1,
-	 "(MCInterfaceElement whichElement, void * element) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MCInterfaceElement whichElement, void * element) -> (ComponentResult _rv)")},
 	{"MCAddMovieSegment", (PyCFunction)MovieCtlObj_MCAddMovieSegment, 1,
-	 "(Movie srcMovie, Boolean scaled) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(Movie srcMovie, Boolean scaled) -> (ComponentResult _rv)")},
 	{"MCTrimMovieSegment", (PyCFunction)MovieCtlObj_MCTrimMovieSegment, 1,
-	 "() -> (ComponentResult _rv)"},
+	 PyDoc_STR("() -> (ComponentResult _rv)")},
 	{NULL, NULL, 0}
 };
 
@@ -1501,43 +1501,43 @@ static PyObject *TimeBaseObj_GetTimeBaseEffectiveRate(TimeBaseObject *_self, PyO
 
 static PyMethodDef TimeBaseObj_methods[] = {
 	{"DisposeTimeBase", (PyCFunction)TimeBaseObj_DisposeTimeBase, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetTimeBaseTime", (PyCFunction)TimeBaseObj_GetTimeBaseTime, 1,
-	 "(TimeScale s) -> (TimeValue _rv, TimeRecord tr)"},
+	 PyDoc_STR("(TimeScale s) -> (TimeValue _rv, TimeRecord tr)")},
 	{"SetTimeBaseTime", (PyCFunction)TimeBaseObj_SetTimeBaseTime, 1,
-	 "(TimeRecord tr) -> None"},
+	 PyDoc_STR("(TimeRecord tr) -> None")},
 	{"SetTimeBaseValue", (PyCFunction)TimeBaseObj_SetTimeBaseValue, 1,
-	 "(TimeValue t, TimeScale s) -> None"},
+	 PyDoc_STR("(TimeValue t, TimeScale s) -> None")},
 	{"GetTimeBaseRate", (PyCFunction)TimeBaseObj_GetTimeBaseRate, 1,
-	 "() -> (Fixed _rv)"},
+	 PyDoc_STR("() -> (Fixed _rv)")},
 	{"SetTimeBaseRate", (PyCFunction)TimeBaseObj_SetTimeBaseRate, 1,
-	 "(Fixed r) -> None"},
+	 PyDoc_STR("(Fixed r) -> None")},
 	{"GetTimeBaseStartTime", (PyCFunction)TimeBaseObj_GetTimeBaseStartTime, 1,
-	 "(TimeScale s) -> (TimeValue _rv, TimeRecord tr)"},
+	 PyDoc_STR("(TimeScale s) -> (TimeValue _rv, TimeRecord tr)")},
 	{"SetTimeBaseStartTime", (PyCFunction)TimeBaseObj_SetTimeBaseStartTime, 1,
-	 "(TimeRecord tr) -> None"},
+	 PyDoc_STR("(TimeRecord tr) -> None")},
 	{"GetTimeBaseStopTime", (PyCFunction)TimeBaseObj_GetTimeBaseStopTime, 1,
-	 "(TimeScale s) -> (TimeValue _rv, TimeRecord tr)"},
+	 PyDoc_STR("(TimeScale s) -> (TimeValue _rv, TimeRecord tr)")},
 	{"SetTimeBaseStopTime", (PyCFunction)TimeBaseObj_SetTimeBaseStopTime, 1,
-	 "(TimeRecord tr) -> None"},
+	 PyDoc_STR("(TimeRecord tr) -> None")},
 	{"GetTimeBaseFlags", (PyCFunction)TimeBaseObj_GetTimeBaseFlags, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"SetTimeBaseFlags", (PyCFunction)TimeBaseObj_SetTimeBaseFlags, 1,
-	 "(long timeBaseFlags) -> None"},
+	 PyDoc_STR("(long timeBaseFlags) -> None")},
 	{"SetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_SetTimeBaseMasterTimeBase, 1,
-	 "(TimeBase master, TimeRecord slaveZero) -> None"},
+	 PyDoc_STR("(TimeBase master, TimeRecord slaveZero) -> None")},
 	{"GetTimeBaseMasterTimeBase", (PyCFunction)TimeBaseObj_GetTimeBaseMasterTimeBase, 1,
-	 "() -> (TimeBase _rv)"},
+	 PyDoc_STR("() -> (TimeBase _rv)")},
 	{"SetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_SetTimeBaseMasterClock, 1,
-	 "(Component clockMeister, TimeRecord slaveZero) -> None"},
+	 PyDoc_STR("(Component clockMeister, TimeRecord slaveZero) -> None")},
 	{"GetTimeBaseMasterClock", (PyCFunction)TimeBaseObj_GetTimeBaseMasterClock, 1,
-	 "() -> (ComponentInstance _rv)"},
+	 PyDoc_STR("() -> (ComponentInstance _rv)")},
 	{"GetTimeBaseStatus", (PyCFunction)TimeBaseObj_GetTimeBaseStatus, 1,
-	 "() -> (long _rv, TimeRecord unpinnedTime)"},
+	 PyDoc_STR("() -> (long _rv, TimeRecord unpinnedTime)")},
 	{"SetTimeBaseZero", (PyCFunction)TimeBaseObj_SetTimeBaseZero, 1,
-	 "(TimeRecord zero) -> None"},
+	 PyDoc_STR("(TimeRecord zero) -> None")},
 	{"GetTimeBaseEffectiveRate", (PyCFunction)TimeBaseObj_GetTimeBaseEffectiveRate, 1,
-	 "() -> (Fixed _rv)"},
+	 PyDoc_STR("() -> (Fixed _rv)")},
 	{NULL, NULL, 0}
 };
 
@@ -1825,23 +1825,23 @@ static PyObject *UserDataObj_PutUserDataIntoHandle(UserDataObject *_self, PyObje
 
 static PyMethodDef UserDataObj_methods[] = {
 	{"GetUserData", (PyCFunction)UserDataObj_GetUserData, 1,
-	 "(Handle data, OSType udType, long index) -> None"},
+	 PyDoc_STR("(Handle data, OSType udType, long index) -> None")},
 	{"AddUserData", (PyCFunction)UserDataObj_AddUserData, 1,
-	 "(Handle data, OSType udType) -> None"},
+	 PyDoc_STR("(Handle data, OSType udType) -> None")},
 	{"RemoveUserData", (PyCFunction)UserDataObj_RemoveUserData, 1,
-	 "(OSType udType, long index) -> None"},
+	 PyDoc_STR("(OSType udType, long index) -> None")},
 	{"CountUserDataType", (PyCFunction)UserDataObj_CountUserDataType, 1,
-	 "(OSType udType) -> (short _rv)"},
+	 PyDoc_STR("(OSType udType) -> (short _rv)")},
 	{"GetNextUserDataType", (PyCFunction)UserDataObj_GetNextUserDataType, 1,
-	 "(OSType udType) -> (long _rv)"},
+	 PyDoc_STR("(OSType udType) -> (long _rv)")},
 	{"AddUserDataText", (PyCFunction)UserDataObj_AddUserDataText, 1,
-	 "(Handle data, OSType udType, long index, short itlRegionTag) -> None"},
+	 PyDoc_STR("(Handle data, OSType udType, long index, short itlRegionTag) -> None")},
 	{"GetUserDataText", (PyCFunction)UserDataObj_GetUserDataText, 1,
-	 "(Handle data, OSType udType, long index, short itlRegionTag) -> None"},
+	 PyDoc_STR("(Handle data, OSType udType, long index, short itlRegionTag) -> None")},
 	{"RemoveUserDataText", (PyCFunction)UserDataObj_RemoveUserDataText, 1,
-	 "(OSType udType, long index, short itlRegionTag) -> None"},
+	 PyDoc_STR("(OSType udType, long index, short itlRegionTag) -> None")},
 	{"PutUserDataIntoHandle", (PyCFunction)UserDataObj_PutUserDataIntoHandle, 1,
-	 "(Handle h) -> None"},
+	 PyDoc_STR("(Handle h) -> None")},
 	{NULL, NULL, 0}
 };
 
@@ -2924,99 +2924,99 @@ static PyObject *MediaObj_GetMediaNextInterestingTimeOnly(MediaObject *_self, Py
 
 static PyMethodDef MediaObj_methods[] = {
 	{"LoadMediaIntoRam", (PyCFunction)MediaObj_LoadMediaIntoRam, 1,
-	 "(TimeValue time, TimeValue duration, long flags) -> None"},
+	 PyDoc_STR("(TimeValue time, TimeValue duration, long flags) -> None")},
 	{"GetMediaTrack", (PyCFunction)MediaObj_GetMediaTrack, 1,
-	 "() -> (Track _rv)"},
+	 PyDoc_STR("() -> (Track _rv)")},
 	{"GetMediaCreationTime", (PyCFunction)MediaObj_GetMediaCreationTime, 1,
-	 "() -> (unsigned long _rv)"},
+	 PyDoc_STR("() -> (unsigned long _rv)")},
 	{"GetMediaModificationTime", (PyCFunction)MediaObj_GetMediaModificationTime, 1,
-	 "() -> (unsigned long _rv)"},
+	 PyDoc_STR("() -> (unsigned long _rv)")},
 	{"GetMediaTimeScale", (PyCFunction)MediaObj_GetMediaTimeScale, 1,
-	 "() -> (TimeScale _rv)"},
+	 PyDoc_STR("() -> (TimeScale _rv)")},
 	{"SetMediaTimeScale", (PyCFunction)MediaObj_SetMediaTimeScale, 1,
-	 "(TimeScale timeScale) -> None"},
+	 PyDoc_STR("(TimeScale timeScale) -> None")},
 	{"GetMediaDuration", (PyCFunction)MediaObj_GetMediaDuration, 1,
-	 "() -> (TimeValue _rv)"},
+	 PyDoc_STR("() -> (TimeValue _rv)")},
 	{"GetMediaLanguage", (PyCFunction)MediaObj_GetMediaLanguage, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"SetMediaLanguage", (PyCFunction)MediaObj_SetMediaLanguage, 1,
-	 "(short language) -> None"},
+	 PyDoc_STR("(short language) -> None")},
 	{"GetMediaQuality", (PyCFunction)MediaObj_GetMediaQuality, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"SetMediaQuality", (PyCFunction)MediaObj_SetMediaQuality, 1,
-	 "(short quality) -> None"},
+	 PyDoc_STR("(short quality) -> None")},
 	{"GetMediaHandlerDescription", (PyCFunction)MediaObj_GetMediaHandlerDescription, 1,
-	 "(Str255 creatorName) -> (OSType mediaType, OSType creatorManufacturer)"},
+	 PyDoc_STR("(Str255 creatorName) -> (OSType mediaType, OSType creatorManufacturer)")},
 	{"GetMediaUserData", (PyCFunction)MediaObj_GetMediaUserData, 1,
-	 "() -> (UserData _rv)"},
+	 PyDoc_STR("() -> (UserData _rv)")},
 	{"GetMediaHandler", (PyCFunction)MediaObj_GetMediaHandler, 1,
-	 "() -> (MediaHandler _rv)"},
+	 PyDoc_STR("() -> (MediaHandler _rv)")},
 	{"SetMediaHandler", (PyCFunction)MediaObj_SetMediaHandler, 1,
-	 "(MediaHandlerComponent mH) -> None"},
+	 PyDoc_STR("(MediaHandlerComponent mH) -> None")},
 	{"BeginMediaEdits", (PyCFunction)MediaObj_BeginMediaEdits, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"EndMediaEdits", (PyCFunction)MediaObj_EndMediaEdits, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"SetMediaDefaultDataRefIndex", (PyCFunction)MediaObj_SetMediaDefaultDataRefIndex, 1,
-	 "(short index) -> None"},
+	 PyDoc_STR("(short index) -> None")},
 	{"GetMediaDataHandlerDescription", (PyCFunction)MediaObj_GetMediaDataHandlerDescription, 1,
-	 "(short index, Str255 creatorName) -> (OSType dhType, OSType creatorManufacturer)"},
+	 PyDoc_STR("(short index, Str255 creatorName) -> (OSType dhType, OSType creatorManufacturer)")},
 	{"GetMediaDataHandler", (PyCFunction)MediaObj_GetMediaDataHandler, 1,
-	 "(short index) -> (DataHandler _rv)"},
+	 PyDoc_STR("(short index) -> (DataHandler _rv)")},
 	{"SetMediaDataHandler", (PyCFunction)MediaObj_SetMediaDataHandler, 1,
-	 "(short index, DataHandlerComponent dataHandler) -> None"},
+	 PyDoc_STR("(short index, DataHandlerComponent dataHandler) -> None")},
 	{"GetMediaSampleDescriptionCount", (PyCFunction)MediaObj_GetMediaSampleDescriptionCount, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"GetMediaSampleDescription", (PyCFunction)MediaObj_GetMediaSampleDescription, 1,
-	 "(long index, SampleDescriptionHandle descH) -> None"},
+	 PyDoc_STR("(long index, SampleDescriptionHandle descH) -> None")},
 	{"SetMediaSampleDescription", (PyCFunction)MediaObj_SetMediaSampleDescription, 1,
-	 "(long index, SampleDescriptionHandle descH) -> None"},
+	 PyDoc_STR("(long index, SampleDescriptionHandle descH) -> None")},
 	{"GetMediaSampleCount", (PyCFunction)MediaObj_GetMediaSampleCount, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"GetMediaSyncSampleCount", (PyCFunction)MediaObj_GetMediaSyncSampleCount, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"SampleNumToMediaTime", (PyCFunction)MediaObj_SampleNumToMediaTime, 1,
-	 "(long logicalSampleNum) -> (TimeValue sampleTime, TimeValue sampleDuration)"},
+	 PyDoc_STR("(long logicalSampleNum) -> (TimeValue sampleTime, TimeValue sampleDuration)")},
 	{"MediaTimeToSampleNum", (PyCFunction)MediaObj_MediaTimeToSampleNum, 1,
-	 "(TimeValue time) -> (long sampleNum, TimeValue sampleTime, TimeValue sampleDuration)"},
+	 PyDoc_STR("(TimeValue time) -> (long sampleNum, TimeValue sampleTime, TimeValue sampleDuration)")},
 	{"AddMediaSample", (PyCFunction)MediaObj_AddMediaSample, 1,
-	 "(Handle dataIn, long inOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)"},
+	 PyDoc_STR("(Handle dataIn, long inOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)")},
 	{"AddMediaSampleReference", (PyCFunction)MediaObj_AddMediaSampleReference, 1,
-	 "(long dataOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)"},
+	 PyDoc_STR("(long dataOffset, unsigned long size, TimeValue durationPerSample, SampleDescriptionHandle sampleDescriptionH, long numberOfSamples, short sampleFlags) -> (TimeValue sampleTime)")},
 	{"GetMediaSample", (PyCFunction)MediaObj_GetMediaSample, 1,
-	 "(Handle dataOut, long maxSizeToGrow, TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)"},
+	 PyDoc_STR("(Handle dataOut, long maxSizeToGrow, TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)")},
 	{"GetMediaSampleReference", (PyCFunction)MediaObj_GetMediaSampleReference, 1,
-	 "(TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long dataOffset, long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)"},
+	 PyDoc_STR("(TimeValue time, SampleDescriptionHandle sampleDescriptionH, long maxNumberOfSamples) -> (long dataOffset, long size, TimeValue sampleTime, TimeValue durationPerSample, long sampleDescriptionIndex, long numberOfSamples, short sampleFlags)")},
 	{"SetMediaPreferredChunkSize", (PyCFunction)MediaObj_SetMediaPreferredChunkSize, 1,
-	 "(long maxChunkSize) -> None"},
+	 PyDoc_STR("(long maxChunkSize) -> None")},
 	{"GetMediaPreferredChunkSize", (PyCFunction)MediaObj_GetMediaPreferredChunkSize, 1,
-	 "() -> (long maxChunkSize)"},
+	 PyDoc_STR("() -> (long maxChunkSize)")},
 	{"SetMediaShadowSync", (PyCFunction)MediaObj_SetMediaShadowSync, 1,
-	 "(long frameDiffSampleNum, long syncSampleNum) -> None"},
+	 PyDoc_STR("(long frameDiffSampleNum, long syncSampleNum) -> None")},
 	{"GetMediaShadowSync", (PyCFunction)MediaObj_GetMediaShadowSync, 1,
-	 "(long frameDiffSampleNum) -> (long syncSampleNum)"},
+	 PyDoc_STR("(long frameDiffSampleNum) -> (long syncSampleNum)")},
 	{"GetMediaDataSize", (PyCFunction)MediaObj_GetMediaDataSize, 1,
-	 "(TimeValue startTime, TimeValue duration) -> (long _rv)"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (long _rv)")},
 	{"GetMediaDataSize64", (PyCFunction)MediaObj_GetMediaDataSize64, 1,
-	 "(TimeValue startTime, TimeValue duration) -> (wide dataSize)"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (wide dataSize)")},
 	{"GetMediaNextInterestingTime", (PyCFunction)MediaObj_GetMediaNextInterestingTime, 1,
-	 "(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
+	 PyDoc_STR("(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)")},
 	{"GetMediaDataRef", (PyCFunction)MediaObj_GetMediaDataRef, 1,
-	 "(short index) -> (Handle dataRef, OSType dataRefType, long dataRefAttributes)"},
+	 PyDoc_STR("(short index) -> (Handle dataRef, OSType dataRefType, long dataRefAttributes)")},
 	{"SetMediaDataRef", (PyCFunction)MediaObj_SetMediaDataRef, 1,
-	 "(short index, Handle dataRef, OSType dataRefType) -> None"},
+	 PyDoc_STR("(short index, Handle dataRef, OSType dataRefType) -> None")},
 	{"SetMediaDataRefAttributes", (PyCFunction)MediaObj_SetMediaDataRefAttributes, 1,
-	 "(short index, long dataRefAttributes) -> None"},
+	 PyDoc_STR("(short index, long dataRefAttributes) -> None")},
 	{"AddMediaDataRef", (PyCFunction)MediaObj_AddMediaDataRef, 1,
-	 "(Handle dataRef, OSType dataRefType) -> (short index)"},
+	 PyDoc_STR("(Handle dataRef, OSType dataRefType) -> (short index)")},
 	{"GetMediaDataRefCount", (PyCFunction)MediaObj_GetMediaDataRefCount, 1,
-	 "() -> (short count)"},
+	 PyDoc_STR("() -> (short count)")},
 	{"SetMediaPlayHints", (PyCFunction)MediaObj_SetMediaPlayHints, 1,
-	 "(long flags, long flagsMask) -> None"},
+	 PyDoc_STR("(long flags, long flagsMask) -> None")},
 	{"GetMediaPlayHints", (PyCFunction)MediaObj_GetMediaPlayHints, 1,
-	 "() -> (long flags)"},
+	 PyDoc_STR("() -> (long flags)")},
 	{"GetMediaNextInterestingTimeOnly", (PyCFunction)MediaObj_GetMediaNextInterestingTimeOnly, 1,
-	 "(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime)"},
+	 PyDoc_STR("(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime)")},
 	{NULL, NULL, 0}
 };
 
@@ -4185,119 +4185,119 @@ static PyObject *TrackObj_GetTrackLoadSettings(TrackObject *_self, PyObject *_ar
 
 static PyMethodDef TrackObj_methods[] = {
 	{"LoadTrackIntoRam", (PyCFunction)TrackObj_LoadTrackIntoRam, 1,
-	 "(TimeValue time, TimeValue duration, long flags) -> None"},
+	 PyDoc_STR("(TimeValue time, TimeValue duration, long flags) -> None")},
 	{"GetTrackPict", (PyCFunction)TrackObj_GetTrackPict, 1,
-	 "(TimeValue time) -> (PicHandle _rv)"},
+	 PyDoc_STR("(TimeValue time) -> (PicHandle _rv)")},
 	{"GetTrackClipRgn", (PyCFunction)TrackObj_GetTrackClipRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"SetTrackClipRgn", (PyCFunction)TrackObj_SetTrackClipRgn, 1,
-	 "(RgnHandle theClip) -> None"},
+	 PyDoc_STR("(RgnHandle theClip) -> None")},
 	{"GetTrackDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackDisplayBoundsRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"GetTrackMovieBoundsRgn", (PyCFunction)TrackObj_GetTrackMovieBoundsRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"GetTrackBoundsRgn", (PyCFunction)TrackObj_GetTrackBoundsRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"GetTrackMatte", (PyCFunction)TrackObj_GetTrackMatte, 1,
-	 "() -> (PixMapHandle _rv)"},
+	 PyDoc_STR("() -> (PixMapHandle _rv)")},
 	{"SetTrackMatte", (PyCFunction)TrackObj_SetTrackMatte, 1,
-	 "(PixMapHandle theMatte) -> None"},
+	 PyDoc_STR("(PixMapHandle theMatte) -> None")},
 	{"GetTrackID", (PyCFunction)TrackObj_GetTrackID, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"GetTrackMovie", (PyCFunction)TrackObj_GetTrackMovie, 1,
-	 "() -> (Movie _rv)"},
+	 PyDoc_STR("() -> (Movie _rv)")},
 	{"GetTrackCreationTime", (PyCFunction)TrackObj_GetTrackCreationTime, 1,
-	 "() -> (unsigned long _rv)"},
+	 PyDoc_STR("() -> (unsigned long _rv)")},
 	{"GetTrackModificationTime", (PyCFunction)TrackObj_GetTrackModificationTime, 1,
-	 "() -> (unsigned long _rv)"},
+	 PyDoc_STR("() -> (unsigned long _rv)")},
 	{"GetTrackEnabled", (PyCFunction)TrackObj_GetTrackEnabled, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"SetTrackEnabled", (PyCFunction)TrackObj_SetTrackEnabled, 1,
-	 "(Boolean isEnabled) -> None"},
+	 PyDoc_STR("(Boolean isEnabled) -> None")},
 	{"GetTrackUsage", (PyCFunction)TrackObj_GetTrackUsage, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"SetTrackUsage", (PyCFunction)TrackObj_SetTrackUsage, 1,
-	 "(long usage) -> None"},
+	 PyDoc_STR("(long usage) -> None")},
 	{"GetTrackDuration", (PyCFunction)TrackObj_GetTrackDuration, 1,
-	 "() -> (TimeValue _rv)"},
+	 PyDoc_STR("() -> (TimeValue _rv)")},
 	{"GetTrackOffset", (PyCFunction)TrackObj_GetTrackOffset, 1,
-	 "() -> (TimeValue _rv)"},
+	 PyDoc_STR("() -> (TimeValue _rv)")},
 	{"SetTrackOffset", (PyCFunction)TrackObj_SetTrackOffset, 1,
-	 "(TimeValue movieOffsetTime) -> None"},
+	 PyDoc_STR("(TimeValue movieOffsetTime) -> None")},
 	{"GetTrackLayer", (PyCFunction)TrackObj_GetTrackLayer, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"SetTrackLayer", (PyCFunction)TrackObj_SetTrackLayer, 1,
-	 "(short layer) -> None"},
+	 PyDoc_STR("(short layer) -> None")},
 	{"GetTrackAlternate", (PyCFunction)TrackObj_GetTrackAlternate, 1,
-	 "() -> (Track _rv)"},
+	 PyDoc_STR("() -> (Track _rv)")},
 	{"SetTrackAlternate", (PyCFunction)TrackObj_SetTrackAlternate, 1,
-	 "(Track alternateT) -> None"},
+	 PyDoc_STR("(Track alternateT) -> None")},
 	{"GetTrackVolume", (PyCFunction)TrackObj_GetTrackVolume, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"SetTrackVolume", (PyCFunction)TrackObj_SetTrackVolume, 1,
-	 "(short volume) -> None"},
+	 PyDoc_STR("(short volume) -> None")},
 	{"GetTrackDimensions", (PyCFunction)TrackObj_GetTrackDimensions, 1,
-	 "() -> (Fixed width, Fixed height)"},
+	 PyDoc_STR("() -> (Fixed width, Fixed height)")},
 	{"SetTrackDimensions", (PyCFunction)TrackObj_SetTrackDimensions, 1,
-	 "(Fixed width, Fixed height) -> None"},
+	 PyDoc_STR("(Fixed width, Fixed height) -> None")},
 	{"GetTrackUserData", (PyCFunction)TrackObj_GetTrackUserData, 1,
-	 "() -> (UserData _rv)"},
+	 PyDoc_STR("() -> (UserData _rv)")},
 	{"GetTrackSoundLocalizationSettings", (PyCFunction)TrackObj_GetTrackSoundLocalizationSettings, 1,
-	 "() -> (Handle settings)"},
+	 PyDoc_STR("() -> (Handle settings)")},
 	{"SetTrackSoundLocalizationSettings", (PyCFunction)TrackObj_SetTrackSoundLocalizationSettings, 1,
-	 "(Handle settings) -> None"},
+	 PyDoc_STR("(Handle settings) -> None")},
 	{"NewTrackMedia", (PyCFunction)TrackObj_NewTrackMedia, 1,
-	 "(OSType mediaType, TimeScale timeScale, Handle dataRef, OSType dataRefType) -> (Media _rv)"},
+	 PyDoc_STR("(OSType mediaType, TimeScale timeScale, Handle dataRef, OSType dataRefType) -> (Media _rv)")},
 	{"GetTrackMedia", (PyCFunction)TrackObj_GetTrackMedia, 1,
-	 "() -> (Media _rv)"},
+	 PyDoc_STR("() -> (Media _rv)")},
 	{"InsertMediaIntoTrack", (PyCFunction)TrackObj_InsertMediaIntoTrack, 1,
-	 "(TimeValue trackStart, TimeValue mediaTime, TimeValue mediaDuration, Fixed mediaRate) -> None"},
+	 PyDoc_STR("(TimeValue trackStart, TimeValue mediaTime, TimeValue mediaDuration, Fixed mediaRate) -> None")},
 	{"InsertTrackSegment", (PyCFunction)TrackObj_InsertTrackSegment, 1,
-	 "(Track dstTrack, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None"},
+	 PyDoc_STR("(Track dstTrack, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None")},
 	{"InsertEmptyTrackSegment", (PyCFunction)TrackObj_InsertEmptyTrackSegment, 1,
-	 "(TimeValue dstIn, TimeValue dstDuration) -> None"},
+	 PyDoc_STR("(TimeValue dstIn, TimeValue dstDuration) -> None")},
 	{"DeleteTrackSegment", (PyCFunction)TrackObj_DeleteTrackSegment, 1,
-	 "(TimeValue startTime, TimeValue duration) -> None"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue duration) -> None")},
 	{"ScaleTrackSegment", (PyCFunction)TrackObj_ScaleTrackSegment, 1,
-	 "(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None")},
 	{"IsScrapMovie", (PyCFunction)TrackObj_IsScrapMovie, 1,
-	 "() -> (Component _rv)"},
+	 PyDoc_STR("() -> (Component _rv)")},
 	{"CopyTrackSettings", (PyCFunction)TrackObj_CopyTrackSettings, 1,
-	 "(Track dstTrack) -> None"},
+	 PyDoc_STR("(Track dstTrack) -> None")},
 	{"AddEmptyTrackToMovie", (PyCFunction)TrackObj_AddEmptyTrackToMovie, 1,
-	 "(Movie dstMovie, Handle dataRef, OSType dataRefType) -> (Track dstTrack)"},
+	 PyDoc_STR("(Movie dstMovie, Handle dataRef, OSType dataRefType) -> (Track dstTrack)")},
 	{"AddClonedTrackToMovie", (PyCFunction)TrackObj_AddClonedTrackToMovie, 1,
-	 "(Movie dstMovie, long flags) -> (Track dstTrack)"},
+	 PyDoc_STR("(Movie dstMovie, long flags) -> (Track dstTrack)")},
 	{"AddTrackReference", (PyCFunction)TrackObj_AddTrackReference, 1,
-	 "(Track refTrack, OSType refType) -> (long addedIndex)"},
+	 PyDoc_STR("(Track refTrack, OSType refType) -> (long addedIndex)")},
 	{"DeleteTrackReference", (PyCFunction)TrackObj_DeleteTrackReference, 1,
-	 "(OSType refType, long index) -> None"},
+	 PyDoc_STR("(OSType refType, long index) -> None")},
 	{"SetTrackReference", (PyCFunction)TrackObj_SetTrackReference, 1,
-	 "(Track refTrack, OSType refType, long index) -> None"},
+	 PyDoc_STR("(Track refTrack, OSType refType, long index) -> None")},
 	{"GetTrackReference", (PyCFunction)TrackObj_GetTrackReference, 1,
-	 "(OSType refType, long index) -> (Track _rv)"},
+	 PyDoc_STR("(OSType refType, long index) -> (Track _rv)")},
 	{"GetNextTrackReferenceType", (PyCFunction)TrackObj_GetNextTrackReferenceType, 1,
-	 "(OSType refType) -> (OSType _rv)"},
+	 PyDoc_STR("(OSType refType) -> (OSType _rv)")},
 	{"GetTrackReferenceCount", (PyCFunction)TrackObj_GetTrackReferenceCount, 1,
-	 "(OSType refType) -> (long _rv)"},
+	 PyDoc_STR("(OSType refType) -> (long _rv)")},
 	{"GetTrackEditRate", (PyCFunction)TrackObj_GetTrackEditRate, 1,
-	 "(TimeValue atTime) -> (Fixed _rv)"},
+	 PyDoc_STR("(TimeValue atTime) -> (Fixed _rv)")},
 	{"GetTrackDataSize", (PyCFunction)TrackObj_GetTrackDataSize, 1,
-	 "(TimeValue startTime, TimeValue duration) -> (long _rv)"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (long _rv)")},
 	{"GetTrackDataSize64", (PyCFunction)TrackObj_GetTrackDataSize64, 1,
-	 "(TimeValue startTime, TimeValue duration) -> (wide dataSize)"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (wide dataSize)")},
 	{"PtInTrack", (PyCFunction)TrackObj_PtInTrack, 1,
-	 "(Point pt) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point pt) -> (Boolean _rv)")},
 	{"GetTrackNextInterestingTime", (PyCFunction)TrackObj_GetTrackNextInterestingTime, 1,
-	 "(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
+	 PyDoc_STR("(short interestingTimeFlags, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)")},
 	{"GetTrackSegmentDisplayBoundsRgn", (PyCFunction)TrackObj_GetTrackSegmentDisplayBoundsRgn, 1,
-	 "(TimeValue time, TimeValue duration) -> (RgnHandle _rv)"},
+	 PyDoc_STR("(TimeValue time, TimeValue duration) -> (RgnHandle _rv)")},
 	{"GetTrackStatus", (PyCFunction)TrackObj_GetTrackStatus, 1,
-	 "() -> (ComponentResult _rv)"},
+	 PyDoc_STR("() -> (ComponentResult _rv)")},
 	{"SetTrackLoadSettings", (PyCFunction)TrackObj_SetTrackLoadSettings, 1,
-	 "(TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints) -> None"},
+	 PyDoc_STR("(TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints) -> None")},
 	{"GetTrackLoadSettings", (PyCFunction)TrackObj_GetTrackLoadSettings, 1,
-	 "() -> (TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints)"},
+	 PyDoc_STR("() -> (TimeValue preloadTime, TimeValue preloadDuration, long preloadFlags, long defaultHints)")},
 	{NULL, NULL, 0}
 };
 
@@ -6489,236 +6489,236 @@ static PyObject *MovieObj_QTGetDataRefMaxFileOffset(MovieObject *_self, PyObject
 
 static PyMethodDef MovieObj_methods[] = {
 	{"MoviesTask", (PyCFunction)MovieObj_MoviesTask, 1,
-	 "(long maxMilliSecToUse) -> None"},
+	 PyDoc_STR("(long maxMilliSecToUse) -> None")},
 	{"PrerollMovie", (PyCFunction)MovieObj_PrerollMovie, 1,
-	 "(TimeValue time, Fixed Rate) -> None"},
+	 PyDoc_STR("(TimeValue time, Fixed Rate) -> None")},
 	{"AbortPrePrerollMovie", (PyCFunction)MovieObj_AbortPrePrerollMovie, 1,
-	 "(OSErr err) -> None"},
+	 PyDoc_STR("(OSErr err) -> None")},
 	{"LoadMovieIntoRam", (PyCFunction)MovieObj_LoadMovieIntoRam, 1,
-	 "(TimeValue time, TimeValue duration, long flags) -> None"},
+	 PyDoc_STR("(TimeValue time, TimeValue duration, long flags) -> None")},
 	{"SetMovieActive", (PyCFunction)MovieObj_SetMovieActive, 1,
-	 "(Boolean active) -> None"},
+	 PyDoc_STR("(Boolean active) -> None")},
 	{"GetMovieActive", (PyCFunction)MovieObj_GetMovieActive, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"StartMovie", (PyCFunction)MovieObj_StartMovie, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"StopMovie", (PyCFunction)MovieObj_StopMovie, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GoToBeginningOfMovie", (PyCFunction)MovieObj_GoToBeginningOfMovie, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GoToEndOfMovie", (PyCFunction)MovieObj_GoToEndOfMovie, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"IsMovieDone", (PyCFunction)MovieObj_IsMovieDone, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"GetMoviePreviewMode", (PyCFunction)MovieObj_GetMoviePreviewMode, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"SetMoviePreviewMode", (PyCFunction)MovieObj_SetMoviePreviewMode, 1,
-	 "(Boolean usePreview) -> None"},
+	 PyDoc_STR("(Boolean usePreview) -> None")},
 	{"ShowMoviePoster", (PyCFunction)MovieObj_ShowMoviePoster, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetMovieTimeBase", (PyCFunction)MovieObj_GetMovieTimeBase, 1,
-	 "() -> (TimeBase _rv)"},
+	 PyDoc_STR("() -> (TimeBase _rv)")},
 	{"SetMovieMasterTimeBase", (PyCFunction)MovieObj_SetMovieMasterTimeBase, 1,
-	 "(TimeBase tb, TimeRecord slaveZero) -> None"},
+	 PyDoc_STR("(TimeBase tb, TimeRecord slaveZero) -> None")},
 	{"SetMovieMasterClock", (PyCFunction)MovieObj_SetMovieMasterClock, 1,
-	 "(Component clockMeister, TimeRecord slaveZero) -> None"},
+	 PyDoc_STR("(Component clockMeister, TimeRecord slaveZero) -> None")},
 	{"GetMovieGWorld", (PyCFunction)MovieObj_GetMovieGWorld, 1,
-	 "() -> (CGrafPtr port, GDHandle gdh)"},
+	 PyDoc_STR("() -> (CGrafPtr port, GDHandle gdh)")},
 	{"SetMovieGWorld", (PyCFunction)MovieObj_SetMovieGWorld, 1,
-	 "(CGrafPtr port, GDHandle gdh) -> None"},
+	 PyDoc_STR("(CGrafPtr port, GDHandle gdh) -> None")},
 	{"GetMovieNaturalBoundsRect", (PyCFunction)MovieObj_GetMovieNaturalBoundsRect, 1,
-	 "() -> (Rect naturalBounds)"},
+	 PyDoc_STR("() -> (Rect naturalBounds)")},
 	{"GetNextTrackForCompositing", (PyCFunction)MovieObj_GetNextTrackForCompositing, 1,
-	 "(Track theTrack) -> (Track _rv)"},
+	 PyDoc_STR("(Track theTrack) -> (Track _rv)")},
 	{"GetPrevTrackForCompositing", (PyCFunction)MovieObj_GetPrevTrackForCompositing, 1,
-	 "(Track theTrack) -> (Track _rv)"},
+	 PyDoc_STR("(Track theTrack) -> (Track _rv)")},
 	{"GetMoviePict", (PyCFunction)MovieObj_GetMoviePict, 1,
-	 "(TimeValue time) -> (PicHandle _rv)"},
+	 PyDoc_STR("(TimeValue time) -> (PicHandle _rv)")},
 	{"GetMoviePosterPict", (PyCFunction)MovieObj_GetMoviePosterPict, 1,
-	 "() -> (PicHandle _rv)"},
+	 PyDoc_STR("() -> (PicHandle _rv)")},
 	{"UpdateMovie", (PyCFunction)MovieObj_UpdateMovie, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"InvalidateMovieRegion", (PyCFunction)MovieObj_InvalidateMovieRegion, 1,
-	 "(RgnHandle invalidRgn) -> None"},
+	 PyDoc_STR("(RgnHandle invalidRgn) -> None")},
 	{"GetMovieBox", (PyCFunction)MovieObj_GetMovieBox, 1,
-	 "() -> (Rect boxRect)"},
+	 PyDoc_STR("() -> (Rect boxRect)")},
 	{"SetMovieBox", (PyCFunction)MovieObj_SetMovieBox, 1,
-	 "(Rect boxRect) -> None"},
+	 PyDoc_STR("(Rect boxRect) -> None")},
 	{"GetMovieDisplayClipRgn", (PyCFunction)MovieObj_GetMovieDisplayClipRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"SetMovieDisplayClipRgn", (PyCFunction)MovieObj_SetMovieDisplayClipRgn, 1,
-	 "(RgnHandle theClip) -> None"},
+	 PyDoc_STR("(RgnHandle theClip) -> None")},
 	{"GetMovieClipRgn", (PyCFunction)MovieObj_GetMovieClipRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"SetMovieClipRgn", (PyCFunction)MovieObj_SetMovieClipRgn, 1,
-	 "(RgnHandle theClip) -> None"},
+	 PyDoc_STR("(RgnHandle theClip) -> None")},
 	{"GetMovieDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieDisplayBoundsRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"GetMovieBoundsRgn", (PyCFunction)MovieObj_GetMovieBoundsRgn, 1,
-	 "() -> (RgnHandle _rv)"},
+	 PyDoc_STR("() -> (RgnHandle _rv)")},
 	{"SetMovieVideoOutput", (PyCFunction)MovieObj_SetMovieVideoOutput, 1,
-	 "(ComponentInstance vout) -> None"},
+	 PyDoc_STR("(ComponentInstance vout) -> None")},
 	{"PutMovieIntoHandle", (PyCFunction)MovieObj_PutMovieIntoHandle, 1,
-	 "(Handle publicMovie) -> None"},
+	 PyDoc_STR("(Handle publicMovie) -> None")},
 	{"PutMovieIntoDataFork", (PyCFunction)MovieObj_PutMovieIntoDataFork, 1,
-	 "(short fRefNum, long offset, long maxSize) -> None"},
+	 PyDoc_STR("(short fRefNum, long offset, long maxSize) -> None")},
 	{"PutMovieIntoDataFork64", (PyCFunction)MovieObj_PutMovieIntoDataFork64, 1,
-	 "(long fRefNum, wide offset, unsigned long maxSize) -> None"},
+	 PyDoc_STR("(long fRefNum, wide offset, unsigned long maxSize) -> None")},
 	{"GetMovieCreationTime", (PyCFunction)MovieObj_GetMovieCreationTime, 1,
-	 "() -> (unsigned long _rv)"},
+	 PyDoc_STR("() -> (unsigned long _rv)")},
 	{"GetMovieModificationTime", (PyCFunction)MovieObj_GetMovieModificationTime, 1,
-	 "() -> (unsigned long _rv)"},
+	 PyDoc_STR("() -> (unsigned long _rv)")},
 	{"GetMovieTimeScale", (PyCFunction)MovieObj_GetMovieTimeScale, 1,
-	 "() -> (TimeScale _rv)"},
+	 PyDoc_STR("() -> (TimeScale _rv)")},
 	{"SetMovieTimeScale", (PyCFunction)MovieObj_SetMovieTimeScale, 1,
-	 "(TimeScale timeScale) -> None"},
+	 PyDoc_STR("(TimeScale timeScale) -> None")},
 	{"GetMovieDuration", (PyCFunction)MovieObj_GetMovieDuration, 1,
-	 "() -> (TimeValue _rv)"},
+	 PyDoc_STR("() -> (TimeValue _rv)")},
 	{"GetMovieRate", (PyCFunction)MovieObj_GetMovieRate, 1,
-	 "() -> (Fixed _rv)"},
+	 PyDoc_STR("() -> (Fixed _rv)")},
 	{"SetMovieRate", (PyCFunction)MovieObj_SetMovieRate, 1,
-	 "(Fixed rate) -> None"},
+	 PyDoc_STR("(Fixed rate) -> None")},
 	{"GetMoviePreferredRate", (PyCFunction)MovieObj_GetMoviePreferredRate, 1,
-	 "() -> (Fixed _rv)"},
+	 PyDoc_STR("() -> (Fixed _rv)")},
 	{"SetMoviePreferredRate", (PyCFunction)MovieObj_SetMoviePreferredRate, 1,
-	 "(Fixed rate) -> None"},
+	 PyDoc_STR("(Fixed rate) -> None")},
 	{"GetMoviePreferredVolume", (PyCFunction)MovieObj_GetMoviePreferredVolume, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"SetMoviePreferredVolume", (PyCFunction)MovieObj_SetMoviePreferredVolume, 1,
-	 "(short volume) -> None"},
+	 PyDoc_STR("(short volume) -> None")},
 	{"GetMovieVolume", (PyCFunction)MovieObj_GetMovieVolume, 1,
-	 "() -> (short _rv)"},
+	 PyDoc_STR("() -> (short _rv)")},
 	{"SetMovieVolume", (PyCFunction)MovieObj_SetMovieVolume, 1,
-	 "(short volume) -> None"},
+	 PyDoc_STR("(short volume) -> None")},
 	{"GetMoviePreviewTime", (PyCFunction)MovieObj_GetMoviePreviewTime, 1,
-	 "() -> (TimeValue previewTime, TimeValue previewDuration)"},
+	 PyDoc_STR("() -> (TimeValue previewTime, TimeValue previewDuration)")},
 	{"SetMoviePreviewTime", (PyCFunction)MovieObj_SetMoviePreviewTime, 1,
-	 "(TimeValue previewTime, TimeValue previewDuration) -> None"},
+	 PyDoc_STR("(TimeValue previewTime, TimeValue previewDuration) -> None")},
 	{"GetMoviePosterTime", (PyCFunction)MovieObj_GetMoviePosterTime, 1,
-	 "() -> (TimeValue _rv)"},
+	 PyDoc_STR("() -> (TimeValue _rv)")},
 	{"SetMoviePosterTime", (PyCFunction)MovieObj_SetMoviePosterTime, 1,
-	 "(TimeValue posterTime) -> None"},
+	 PyDoc_STR("(TimeValue posterTime) -> None")},
 	{"GetMovieSelection", (PyCFunction)MovieObj_GetMovieSelection, 1,
-	 "() -> (TimeValue selectionTime, TimeValue selectionDuration)"},
+	 PyDoc_STR("() -> (TimeValue selectionTime, TimeValue selectionDuration)")},
 	{"SetMovieSelection", (PyCFunction)MovieObj_SetMovieSelection, 1,
-	 "(TimeValue selectionTime, TimeValue selectionDuration) -> None"},
+	 PyDoc_STR("(TimeValue selectionTime, TimeValue selectionDuration) -> None")},
 	{"SetMovieActiveSegment", (PyCFunction)MovieObj_SetMovieActiveSegment, 1,
-	 "(TimeValue startTime, TimeValue duration) -> None"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue duration) -> None")},
 	{"GetMovieActiveSegment", (PyCFunction)MovieObj_GetMovieActiveSegment, 1,
-	 "() -> (TimeValue startTime, TimeValue duration)"},
+	 PyDoc_STR("() -> (TimeValue startTime, TimeValue duration)")},
 	{"GetMovieTime", (PyCFunction)MovieObj_GetMovieTime, 1,
-	 "() -> (TimeValue _rv, TimeRecord currentTime)"},
+	 PyDoc_STR("() -> (TimeValue _rv, TimeRecord currentTime)")},
 	{"SetMovieTime", (PyCFunction)MovieObj_SetMovieTime, 1,
-	 "(TimeRecord newtime) -> None"},
+	 PyDoc_STR("(TimeRecord newtime) -> None")},
 	{"SetMovieTimeValue", (PyCFunction)MovieObj_SetMovieTimeValue, 1,
-	 "(TimeValue newtime) -> None"},
+	 PyDoc_STR("(TimeValue newtime) -> None")},
 	{"GetMovieUserData", (PyCFunction)MovieObj_GetMovieUserData, 1,
-	 "() -> (UserData _rv)"},
+	 PyDoc_STR("() -> (UserData _rv)")},
 	{"GetMovieTrackCount", (PyCFunction)MovieObj_GetMovieTrackCount, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 	{"GetMovieTrack", (PyCFunction)MovieObj_GetMovieTrack, 1,
-	 "(long trackID) -> (Track _rv)"},
+	 PyDoc_STR("(long trackID) -> (Track _rv)")},
 	{"GetMovieIndTrack", (PyCFunction)MovieObj_GetMovieIndTrack, 1,
-	 "(long index) -> (Track _rv)"},
+	 PyDoc_STR("(long index) -> (Track _rv)")},
 	{"GetMovieIndTrackType", (PyCFunction)MovieObj_GetMovieIndTrackType, 1,
-	 "(long index, OSType trackType, long flags) -> (Track _rv)"},
+	 PyDoc_STR("(long index, OSType trackType, long flags) -> (Track _rv)")},
 	{"NewMovieTrack", (PyCFunction)MovieObj_NewMovieTrack, 1,
-	 "(Fixed width, Fixed height, short trackVolume) -> (Track _rv)"},
+	 PyDoc_STR("(Fixed width, Fixed height, short trackVolume) -> (Track _rv)")},
 	{"SetAutoTrackAlternatesEnabled", (PyCFunction)MovieObj_SetAutoTrackAlternatesEnabled, 1,
-	 "(Boolean enable) -> None"},
+	 PyDoc_STR("(Boolean enable) -> None")},
 	{"SelectMovieAlternates", (PyCFunction)MovieObj_SelectMovieAlternates, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"InsertMovieSegment", (PyCFunction)MovieObj_InsertMovieSegment, 1,
-	 "(Movie dstMovie, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None"},
+	 PyDoc_STR("(Movie dstMovie, TimeValue srcIn, TimeValue srcDuration, TimeValue dstIn) -> None")},
 	{"InsertEmptyMovieSegment", (PyCFunction)MovieObj_InsertEmptyMovieSegment, 1,
-	 "(TimeValue dstIn, TimeValue dstDuration) -> None"},
+	 PyDoc_STR("(TimeValue dstIn, TimeValue dstDuration) -> None")},
 	{"DeleteMovieSegment", (PyCFunction)MovieObj_DeleteMovieSegment, 1,
-	 "(TimeValue startTime, TimeValue duration) -> None"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue duration) -> None")},
 	{"ScaleMovieSegment", (PyCFunction)MovieObj_ScaleMovieSegment, 1,
-	 "(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue oldDuration, TimeValue newDuration) -> None")},
 	{"CutMovieSelection", (PyCFunction)MovieObj_CutMovieSelection, 1,
-	 "() -> (Movie _rv)"},
+	 PyDoc_STR("() -> (Movie _rv)")},
 	{"CopyMovieSelection", (PyCFunction)MovieObj_CopyMovieSelection, 1,
-	 "() -> (Movie _rv)"},
+	 PyDoc_STR("() -> (Movie _rv)")},
 	{"PasteMovieSelection", (PyCFunction)MovieObj_PasteMovieSelection, 1,
-	 "(Movie src) -> None"},
+	 PyDoc_STR("(Movie src) -> None")},
 	{"AddMovieSelection", (PyCFunction)MovieObj_AddMovieSelection, 1,
-	 "(Movie src) -> None"},
+	 PyDoc_STR("(Movie src) -> None")},
 	{"ClearMovieSelection", (PyCFunction)MovieObj_ClearMovieSelection, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"PutMovieIntoTypedHandle", (PyCFunction)MovieObj_PutMovieIntoTypedHandle, 1,
-	 "(Track targetTrack, OSType handleType, Handle publicMovie, TimeValue start, TimeValue dur, long flags, ComponentInstance userComp) -> None"},
+	 PyDoc_STR("(Track targetTrack, OSType handleType, Handle publicMovie, TimeValue start, TimeValue dur, long flags, ComponentInstance userComp) -> None")},
 	{"CopyMovieSettings", (PyCFunction)MovieObj_CopyMovieSettings, 1,
-	 "(Movie dstMovie) -> None"},
+	 PyDoc_STR("(Movie dstMovie) -> None")},
 	{"ConvertMovieToFile", (PyCFunction)MovieObj_ConvertMovieToFile, 1,
-	 "(Track onlyTrack, FSSpec outputFile, OSType fileType, OSType creator, ScriptCode scriptTag, long flags, ComponentInstance userComp) -> (short resID)"},
+	 PyDoc_STR("(Track onlyTrack, FSSpec outputFile, OSType fileType, OSType creator, ScriptCode scriptTag, long flags, ComponentInstance userComp) -> (short resID)")},
 	{"GetMovieDataSize", (PyCFunction)MovieObj_GetMovieDataSize, 1,
-	 "(TimeValue startTime, TimeValue duration) -> (long _rv)"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (long _rv)")},
 	{"GetMovieDataSize64", (PyCFunction)MovieObj_GetMovieDataSize64, 1,
-	 "(TimeValue startTime, TimeValue duration) -> (wide dataSize)"},
+	 PyDoc_STR("(TimeValue startTime, TimeValue duration) -> (wide dataSize)")},
 	{"PtInMovie", (PyCFunction)MovieObj_PtInMovie, 1,
-	 "(Point pt) -> (Boolean _rv)"},
+	 PyDoc_STR("(Point pt) -> (Boolean _rv)")},
 	{"SetMovieLanguage", (PyCFunction)MovieObj_SetMovieLanguage, 1,
-	 "(long language) -> None"},
+	 PyDoc_STR("(long language) -> None")},
 	{"GetMovieNextInterestingTime", (PyCFunction)MovieObj_GetMovieNextInterestingTime, 1,
-	 "(short interestingTimeFlags, short numMediaTypes, OSType whichMediaTypes, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)"},
+	 PyDoc_STR("(short interestingTimeFlags, short numMediaTypes, OSType whichMediaTypes, TimeValue time, Fixed rate) -> (TimeValue interestingTime, TimeValue interestingDuration)")},
 	{"AddMovieResource", (PyCFunction)MovieObj_AddMovieResource, 1,
-	 "(short resRefNum, Str255 resName) -> (short resId)"},
+	 PyDoc_STR("(short resRefNum, Str255 resName) -> (short resId)")},
 	{"UpdateMovieResource", (PyCFunction)MovieObj_UpdateMovieResource, 1,
-	 "(short resRefNum, short resId, Str255 resName) -> None"},
+	 PyDoc_STR("(short resRefNum, short resId, Str255 resName) -> None")},
 	{"HasMovieChanged", (PyCFunction)MovieObj_HasMovieChanged, 1,
-	 "() -> (Boolean _rv)"},
+	 PyDoc_STR("() -> (Boolean _rv)")},
 	{"ClearMovieChanged", (PyCFunction)MovieObj_ClearMovieChanged, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"SetMovieDefaultDataRef", (PyCFunction)MovieObj_SetMovieDefaultDataRef, 1,
-	 "(Handle dataRef, OSType dataRefType) -> None"},
+	 PyDoc_STR("(Handle dataRef, OSType dataRefType) -> None")},
 	{"GetMovieDefaultDataRef", (PyCFunction)MovieObj_GetMovieDefaultDataRef, 1,
-	 "() -> (Handle dataRef, OSType dataRefType)"},
+	 PyDoc_STR("() -> (Handle dataRef, OSType dataRefType)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"SetMovieAnchorDataRef", (PyCFunction)MovieObj_SetMovieAnchorDataRef, 1,
-	 "(Handle dataRef, OSType dataRefType) -> None"},
+	 PyDoc_STR("(Handle dataRef, OSType dataRefType) -> None")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"GetMovieAnchorDataRef", (PyCFunction)MovieObj_GetMovieAnchorDataRef, 1,
-	 "() -> (Handle dataRef, OSType dataRefType, long outFlags)"},
+	 PyDoc_STR("() -> (Handle dataRef, OSType dataRefType, long outFlags)")},
 #endif
 	{"SetMovieColorTable", (PyCFunction)MovieObj_SetMovieColorTable, 1,
-	 "(CTabHandle ctab) -> None"},
+	 PyDoc_STR("(CTabHandle ctab) -> None")},
 	{"GetMovieColorTable", (PyCFunction)MovieObj_GetMovieColorTable, 1,
-	 "() -> (CTabHandle ctab)"},
+	 PyDoc_STR("() -> (CTabHandle ctab)")},
 	{"FlattenMovie", (PyCFunction)MovieObj_FlattenMovie, 1,
-	 "(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Str255 resName) -> (short resId)"},
+	 PyDoc_STR("(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Str255 resName) -> (short resId)")},
 	{"FlattenMovieData", (PyCFunction)MovieObj_FlattenMovieData, 1,
-	 "(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (Movie _rv)"},
+	 PyDoc_STR("(long movieFlattenFlags, FSSpec theFile, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (Movie _rv)")},
 	{"MovieSearchText", (PyCFunction)MovieObj_MovieSearchText, 1,
-	 "(Ptr text, long size, long searchFlags) -> (Track searchTrack, TimeValue searchTime, long searchOffset)"},
+	 PyDoc_STR("(Ptr text, long size, long searchFlags) -> (Track searchTrack, TimeValue searchTime, long searchOffset)")},
 	{"GetPosterBox", (PyCFunction)MovieObj_GetPosterBox, 1,
-	 "() -> (Rect boxRect)"},
+	 PyDoc_STR("() -> (Rect boxRect)")},
 	{"SetPosterBox", (PyCFunction)MovieObj_SetPosterBox, 1,
-	 "(Rect boxRect) -> None"},
+	 PyDoc_STR("(Rect boxRect) -> None")},
 	{"GetMovieSegmentDisplayBoundsRgn", (PyCFunction)MovieObj_GetMovieSegmentDisplayBoundsRgn, 1,
-	 "(TimeValue time, TimeValue duration) -> (RgnHandle _rv)"},
+	 PyDoc_STR("(TimeValue time, TimeValue duration) -> (RgnHandle _rv)")},
 	{"GetMovieStatus", (PyCFunction)MovieObj_GetMovieStatus, 1,
-	 "() -> (ComponentResult _rv, Track firstProblemTrack)"},
+	 PyDoc_STR("() -> (ComponentResult _rv, Track firstProblemTrack)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"GetMovieLoadState", (PyCFunction)MovieObj_GetMovieLoadState, 1,
-	 "() -> (long _rv)"},
+	 PyDoc_STR("() -> (long _rv)")},
 #endif
 	{"NewMovieController", (PyCFunction)MovieObj_NewMovieController, 1,
-	 "(Rect movieRect, long someFlags) -> (MovieController _rv)"},
+	 PyDoc_STR("(Rect movieRect, long someFlags) -> (MovieController _rv)")},
 	{"PutMovieOnScrap", (PyCFunction)MovieObj_PutMovieOnScrap, 1,
-	 "(long movieScrapFlags) -> None"},
+	 PyDoc_STR("(long movieScrapFlags) -> None")},
 	{"SetMoviePlayHints", (PyCFunction)MovieObj_SetMoviePlayHints, 1,
-	 "(long flags, long flagsMask) -> None"},
+	 PyDoc_STR("(long flags, long flagsMask) -> None")},
 	{"GetMaxLoadedTimeInMovie", (PyCFunction)MovieObj_GetMaxLoadedTimeInMovie, 1,
-	 "() -> (TimeValue time)"},
+	 PyDoc_STR("() -> (TimeValue time)")},
 	{"QTMovieNeedsTimeTable", (PyCFunction)MovieObj_QTMovieNeedsTimeTable, 1,
-	 "() -> (Boolean needsTimeTable)"},
+	 PyDoc_STR("() -> (Boolean needsTimeTable)")},
 	{"QTGetDataRefMaxFileOffset", (PyCFunction)MovieObj_QTGetDataRefMaxFileOffset, 1,
-	 "(OSType dataRefType, Handle dataRef) -> (long offset)"},
+	 PyDoc_STR("(OSType dataRefType, Handle dataRef) -> (long offset)")},
 	{NULL, NULL, 0}
 };
 
@@ -9615,262 +9615,262 @@ static PyMethodDef Qt_methods[] = {
 
 #if !TARGET_API_MAC_CARBON
 	{"CheckQuickTimeRegistration", (PyCFunction)Qt_CheckQuickTimeRegistration, 1,
-	 "(void * registrationKey, long flags) -> None"},
+	 PyDoc_STR("(void * registrationKey, long flags) -> None")},
 #endif
 	{"EnterMovies", (PyCFunction)Qt_EnterMovies, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"ExitMovies", (PyCFunction)Qt_ExitMovies, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetMoviesError", (PyCFunction)Qt_GetMoviesError, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"ClearMoviesStickyError", (PyCFunction)Qt_ClearMoviesStickyError, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"GetMoviesStickyError", (PyCFunction)Qt_GetMoviesStickyError, 1,
-	 "() -> None"},
+	 PyDoc_STR("() -> None")},
 	{"DisposeMatte", (PyCFunction)Qt_DisposeMatte, 1,
-	 "(PixMapHandle theMatte) -> None"},
+	 PyDoc_STR("(PixMapHandle theMatte) -> None")},
 	{"NewMovie", (PyCFunction)Qt_NewMovie, 1,
-	 "(long flags) -> (Movie _rv)"},
+	 PyDoc_STR("(long flags) -> (Movie _rv)")},
 	{"GetDataHandler", (PyCFunction)Qt_GetDataHandler, 1,
-	 "(Handle dataRef, OSType dataHandlerSubType, long flags) -> (Component _rv)"},
+	 PyDoc_STR("(Handle dataRef, OSType dataHandlerSubType, long flags) -> (Component _rv)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"OpenADataHandler", (PyCFunction)Qt_OpenADataHandler, 1,
-	 "(Handle dataRef, OSType dataHandlerSubType, Handle anchorDataRef, OSType anchorDataRefType, TimeBase tb, long flags) -> (ComponentInstance dh)"},
+	 PyDoc_STR("(Handle dataRef, OSType dataHandlerSubType, Handle anchorDataRef, OSType anchorDataRefType, TimeBase tb, long flags) -> (ComponentInstance dh)")},
 #endif
 	{"PasteHandleIntoMovie", (PyCFunction)Qt_PasteHandleIntoMovie, 1,
-	 "(Handle h, OSType handleType, Movie theMovie, long flags, ComponentInstance userComp) -> None"},
+	 PyDoc_STR("(Handle h, OSType handleType, Movie theMovie, long flags, ComponentInstance userComp) -> None")},
 	{"GetMovieImporterForDataRef", (PyCFunction)Qt_GetMovieImporterForDataRef, 1,
-	 "(OSType dataRefType, Handle dataRef, long flags) -> (Component importer)"},
+	 PyDoc_STR("(OSType dataRefType, Handle dataRef, long flags) -> (Component importer)")},
 	{"QTGetMIMETypeInfo", (PyCFunction)Qt_QTGetMIMETypeInfo, 1,
-	 "(char* mimeStringStart, short mimeStringLength, OSType infoSelector, void * infoDataPtr) -> (long infoDataSize)"},
+	 PyDoc_STR("(char* mimeStringStart, short mimeStringLength, OSType infoSelector, void * infoDataPtr) -> (long infoDataSize)")},
 	{"TrackTimeToMediaTime", (PyCFunction)Qt_TrackTimeToMediaTime, 1,
-	 "(TimeValue value, Track theTrack) -> (TimeValue _rv)"},
+	 PyDoc_STR("(TimeValue value, Track theTrack) -> (TimeValue _rv)")},
 	{"NewUserData", (PyCFunction)Qt_NewUserData, 1,
-	 "() -> (UserData theUserData)"},
+	 PyDoc_STR("() -> (UserData theUserData)")},
 	{"NewUserDataFromHandle", (PyCFunction)Qt_NewUserDataFromHandle, 1,
-	 "(Handle h) -> (UserData theUserData)"},
+	 PyDoc_STR("(Handle h) -> (UserData theUserData)")},
 	{"CreateMovieFile", (PyCFunction)Qt_CreateMovieFile, 1,
-	 "(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (short resRefNum, Movie newmovie)"},
+	 PyDoc_STR("(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags) -> (short resRefNum, Movie newmovie)")},
 	{"OpenMovieFile", (PyCFunction)Qt_OpenMovieFile, 1,
-	 "(FSSpec fileSpec, SInt8 permission) -> (short resRefNum)"},
+	 PyDoc_STR("(FSSpec fileSpec, SInt8 permission) -> (short resRefNum)")},
 	{"CloseMovieFile", (PyCFunction)Qt_CloseMovieFile, 1,
-	 "(short resRefNum) -> None"},
+	 PyDoc_STR("(short resRefNum) -> None")},
 	{"DeleteMovieFile", (PyCFunction)Qt_DeleteMovieFile, 1,
-	 "(FSSpec fileSpec) -> None"},
+	 PyDoc_STR("(FSSpec fileSpec) -> None")},
 	{"NewMovieFromFile", (PyCFunction)Qt_NewMovieFromFile, 1,
-	 "(short resRefNum, short resId, short newMovieFlags) -> (Movie theMovie, short resId, Boolean dataRefWasChanged)"},
+	 PyDoc_STR("(short resRefNum, short resId, short newMovieFlags) -> (Movie theMovie, short resId, Boolean dataRefWasChanged)")},
 	{"NewMovieFromHandle", (PyCFunction)Qt_NewMovieFromHandle, 1,
-	 "(Handle h, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
+	 PyDoc_STR("(Handle h, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)")},
 	{"NewMovieFromDataFork", (PyCFunction)Qt_NewMovieFromDataFork, 1,
-	 "(short fRefNum, long fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
+	 PyDoc_STR("(short fRefNum, long fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)")},
 	{"NewMovieFromDataFork64", (PyCFunction)Qt_NewMovieFromDataFork64, 1,
-	 "(long fRefNum, wide fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)"},
+	 PyDoc_STR("(long fRefNum, wide fileOffset, short newMovieFlags) -> (Movie theMovie, Boolean dataRefWasChanged)")},
 	{"NewMovieFromDataRef", (PyCFunction)Qt_NewMovieFromDataRef, 1,
-	 "(short flags, Handle dataRef, OSType dataRefType) -> (Movie m, short id)"},
+	 PyDoc_STR("(short flags, Handle dataRef, OSType dataRefType) -> (Movie m, short id)")},
 	{"RemoveMovieResource", (PyCFunction)Qt_RemoveMovieResource, 1,
-	 "(short resRefNum, short resId) -> None"},
+	 PyDoc_STR("(short resRefNum, short resId) -> None")},
 	{"CreateShortcutMovieFile", (PyCFunction)Qt_CreateShortcutMovieFile, 1,
-	 "(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Handle targetDataRef, OSType targetDataRefType) -> None"},
+	 PyDoc_STR("(FSSpec fileSpec, OSType creator, ScriptCode scriptTag, long createMovieFileFlags, Handle targetDataRef, OSType targetDataRefType) -> None")},
 	{"CanQuickTimeOpenFile", (PyCFunction)Qt_CanQuickTimeOpenFile, 1,
-	 "(FSSpec fileSpec, OSType fileType, OSType fileNameExtension, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)"},
+	 PyDoc_STR("(FSSpec fileSpec, OSType fileType, OSType fileNameExtension, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)")},
 	{"CanQuickTimeOpenDataRef", (PyCFunction)Qt_CanQuickTimeOpenDataRef, 1,
-	 "(Handle dataRef, OSType dataRefType, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)"},
+	 PyDoc_STR("(Handle dataRef, OSType dataRefType, UInt32 inFlags) -> (Boolean outCanOpenWithGraphicsImporter, Boolean outCanOpenAsMovie, Boolean outPreferGraphicsImporter)")},
 	{"NewMovieFromScrap", (PyCFunction)Qt_NewMovieFromScrap, 1,
-	 "(long newMovieFlags) -> (Movie _rv)"},
+	 PyDoc_STR("(long newMovieFlags) -> (Movie _rv)")},
 	{"QTNewAlias", (PyCFunction)Qt_QTNewAlias, 1,
-	 "(FSSpec fss, Boolean minimal) -> (AliasHandle alias)"},
+	 PyDoc_STR("(FSSpec fss, Boolean minimal) -> (AliasHandle alias)")},
 	{"EndFullScreen", (PyCFunction)Qt_EndFullScreen, 1,
-	 "(Ptr fullState, long flags) -> None"},
+	 PyDoc_STR("(Ptr fullState, long flags) -> None")},
 	{"AddSoundDescriptionExtension", (PyCFunction)Qt_AddSoundDescriptionExtension, 1,
-	 "(SoundDescriptionHandle desc, Handle extension, OSType idType) -> None"},
+	 PyDoc_STR("(SoundDescriptionHandle desc, Handle extension, OSType idType) -> None")},
 	{"GetSoundDescriptionExtension", (PyCFunction)Qt_GetSoundDescriptionExtension, 1,
-	 "(SoundDescriptionHandle desc, OSType idType) -> (Handle extension)"},
+	 PyDoc_STR("(SoundDescriptionHandle desc, OSType idType) -> (Handle extension)")},
 	{"RemoveSoundDescriptionExtension", (PyCFunction)Qt_RemoveSoundDescriptionExtension, 1,
-	 "(SoundDescriptionHandle desc, OSType idType) -> None"},
+	 PyDoc_STR("(SoundDescriptionHandle desc, OSType idType) -> None")},
 	{"QTIsStandardParameterDialogEvent", (PyCFunction)Qt_QTIsStandardParameterDialogEvent, 1,
-	 "(QTParameterDialog createdDialog) -> (EventRecord pEvent)"},
+	 PyDoc_STR("(QTParameterDialog createdDialog) -> (EventRecord pEvent)")},
 	{"QTDismissStandardParameterDialog", (PyCFunction)Qt_QTDismissStandardParameterDialog, 1,
-	 "(QTParameterDialog createdDialog) -> None"},
+	 PyDoc_STR("(QTParameterDialog createdDialog) -> None")},
 	{"QTStandardParameterDialogDoAction", (PyCFunction)Qt_QTStandardParameterDialogDoAction, 1,
-	 "(QTParameterDialog createdDialog, long action, void * params) -> None"},
+	 PyDoc_STR("(QTParameterDialog createdDialog, long action, void * params) -> None")},
 	{"QTRegisterAccessKey", (PyCFunction)Qt_QTRegisterAccessKey, 1,
-	 "(Str255 accessKeyType, long flags, Handle accessKey) -> None"},
+	 PyDoc_STR("(Str255 accessKeyType, long flags, Handle accessKey) -> None")},
 	{"QTUnregisterAccessKey", (PyCFunction)Qt_QTUnregisterAccessKey, 1,
-	 "(Str255 accessKeyType, long flags, Handle accessKey) -> None"},
+	 PyDoc_STR("(Str255 accessKeyType, long flags, Handle accessKey) -> None")},
 	{"QTTextToNativeText", (PyCFunction)Qt_QTTextToNativeText, 1,
-	 "(Handle theText, long encoding, long flags) -> None"},
+	 PyDoc_STR("(Handle theText, long encoding, long flags) -> None")},
 	{"VideoMediaResetStatistics", (PyCFunction)Qt_VideoMediaResetStatistics, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
 	{"VideoMediaGetStatistics", (PyCFunction)Qt_VideoMediaGetStatistics, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv)")},
 	{"VideoMediaGetStallCount", (PyCFunction)Qt_VideoMediaGetStallCount, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv, unsigned long stalls)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, unsigned long stalls)")},
 	{"VideoMediaSetCodecParameter", (PyCFunction)Qt_VideoMediaSetCodecParameter, 1,
-	 "(MediaHandler mh, CodecType cType, OSType parameterID, long parameterChangeSeed, void * dataPtr, long dataSize) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, CodecType cType, OSType parameterID, long parameterChangeSeed, void * dataPtr, long dataSize) -> (ComponentResult _rv)")},
 	{"VideoMediaGetCodecParameter", (PyCFunction)Qt_VideoMediaGetCodecParameter, 1,
-	 "(MediaHandler mh, CodecType cType, OSType parameterID, Handle outParameterData) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, CodecType cType, OSType parameterID, Handle outParameterData) -> (ComponentResult _rv)")},
 	{"TextMediaAddTextSample", (PyCFunction)Qt_TextMediaAddTextSample, 1,
-	 "(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)"},
+	 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)")},
 	{"TextMediaAddTESample", (PyCFunction)Qt_TextMediaAddTESample, 1,
-	 "(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)"},
+	 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)")},
 	{"TextMediaAddHiliteSample", (PyCFunction)Qt_TextMediaAddHiliteSample, 1,
-	 "(MediaHandler mh, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor rgbHiliteColor, TimeValue sampleTime)"},
+	 PyDoc_STR("(MediaHandler mh, short hiliteStart, short hiliteEnd, TimeValue duration) -> (ComponentResult _rv, RGBColor rgbHiliteColor, TimeValue sampleTime)")},
 	{"TextMediaDrawRaw", (PyCFunction)Qt_TextMediaDrawRaw, 1,
-	 "(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh) -> (ComponentResult _rv)")},
 	{"TextMediaSetTextProperty", (PyCFunction)Qt_TextMediaSetTextProperty, 1,
-	 "(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)")},
 	{"TextMediaRawSetup", (PyCFunction)Qt_TextMediaRawSetup, 1,
-	 "(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh, TimeValue sampleDuration) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, GWorldPtr gw, GDHandle gd, void * data, long dataSize, TextDescriptionHandle tdh, TimeValue sampleDuration) -> (ComponentResult _rv)")},
 	{"TextMediaRawIdle", (PyCFunction)Qt_TextMediaRawIdle, 1,
-	 "(MediaHandler mh, GWorldPtr gw, GDHandle gd, TimeValue sampleTime, long flagsIn) -> (ComponentResult _rv, long flagsOut)"},
+	 PyDoc_STR("(MediaHandler mh, GWorldPtr gw, GDHandle gd, TimeValue sampleTime, long flagsIn) -> (ComponentResult _rv, long flagsOut)")},
 	{"TextMediaGetTextProperty", (PyCFunction)Qt_TextMediaGetTextProperty, 1,
-	 "(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, TimeValue atMediaTime, long propertyType, void * data, long dataSize) -> (ComponentResult _rv)")},
 	{"TextMediaFindNextText", (PyCFunction)Qt_TextMediaFindNextText, 1,
-	 "(MediaHandler mh, Ptr text, long size, short findFlags, TimeValue startTime) -> (ComponentResult _rv, TimeValue foundTime, TimeValue foundDuration, long offset)"},
+	 PyDoc_STR("(MediaHandler mh, Ptr text, long size, short findFlags, TimeValue startTime) -> (ComponentResult _rv, TimeValue foundTime, TimeValue foundDuration, long offset)")},
 	{"TextMediaHiliteTextSample", (PyCFunction)Qt_TextMediaHiliteTextSample, 1,
-	 "(MediaHandler mh, TimeValue sampleTime, short hiliteStart, short hiliteEnd) -> (ComponentResult _rv, RGBColor rgbHiliteColor)"},
+	 PyDoc_STR("(MediaHandler mh, TimeValue sampleTime, short hiliteStart, short hiliteEnd) -> (ComponentResult _rv, RGBColor rgbHiliteColor)")},
 	{"TextMediaSetTextSampleData", (PyCFunction)Qt_TextMediaSetTextSampleData, 1,
-	 "(MediaHandler mh, void * data, OSType dataType) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, void * data, OSType dataType) -> (ComponentResult _rv)")},
 	{"SpriteMediaSetProperty", (PyCFunction)Qt_SpriteMediaSetProperty, 1,
-	 "(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
 	{"SpriteMediaGetProperty", (PyCFunction)Qt_SpriteMediaGetProperty, 1,
-	 "(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, short spriteIndex, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
 	{"SpriteMediaHitTestSprites", (PyCFunction)Qt_SpriteMediaHitTestSprites, 1,
-	 "(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, short spriteHitIndex)"},
+	 PyDoc_STR("(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, short spriteHitIndex)")},
 	{"SpriteMediaCountSprites", (PyCFunction)Qt_SpriteMediaCountSprites, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv, short numSprites)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, short numSprites)")},
 	{"SpriteMediaCountImages", (PyCFunction)Qt_SpriteMediaCountImages, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv, short numImages)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, short numImages)")},
 	{"SpriteMediaGetIndImageDescription", (PyCFunction)Qt_SpriteMediaGetIndImageDescription, 1,
-	 "(MediaHandler mh, short imageIndex, ImageDescriptionHandle imageDescription) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, short imageIndex, ImageDescriptionHandle imageDescription) -> (ComponentResult _rv)")},
 	{"SpriteMediaGetDisplayedSampleNumber", (PyCFunction)Qt_SpriteMediaGetDisplayedSampleNumber, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv, long sampleNum)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, long sampleNum)")},
 	{"SpriteMediaGetSpriteName", (PyCFunction)Qt_SpriteMediaGetSpriteName, 1,
-	 "(MediaHandler mh, QTAtomID spriteID, Str255 spriteName) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, Str255 spriteName) -> (ComponentResult _rv)")},
 	{"SpriteMediaGetImageName", (PyCFunction)Qt_SpriteMediaGetImageName, 1,
-	 "(MediaHandler mh, short imageIndex, Str255 imageName) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, short imageIndex, Str255 imageName) -> (ComponentResult _rv)")},
 	{"SpriteMediaSetSpriteProperty", (PyCFunction)Qt_SpriteMediaSetSpriteProperty, 1,
-	 "(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
 	{"SpriteMediaGetSpriteProperty", (PyCFunction)Qt_SpriteMediaGetSpriteProperty, 1,
-	 "(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, long propertyType, void * propertyValue) -> (ComponentResult _rv)")},
 	{"SpriteMediaHitTestAllSprites", (PyCFunction)Qt_SpriteMediaHitTestAllSprites, 1,
-	 "(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, QTAtomID spriteHitID)"},
+	 PyDoc_STR("(MediaHandler mh, long flags, Point loc) -> (ComponentResult _rv, QTAtomID spriteHitID)")},
 	{"SpriteMediaHitTestOneSprite", (PyCFunction)Qt_SpriteMediaHitTestOneSprite, 1,
-	 "(MediaHandler mh, QTAtomID spriteID, long flags, Point loc) -> (ComponentResult _rv, Boolean wasHit)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID spriteID, long flags, Point loc) -> (ComponentResult _rv, Boolean wasHit)")},
 	{"SpriteMediaSpriteIndexToID", (PyCFunction)Qt_SpriteMediaSpriteIndexToID, 1,
-	 "(MediaHandler mh, short spriteIndex) -> (ComponentResult _rv, QTAtomID spriteID)"},
+	 PyDoc_STR("(MediaHandler mh, short spriteIndex) -> (ComponentResult _rv, QTAtomID spriteID)")},
 	{"SpriteMediaSpriteIDToIndex", (PyCFunction)Qt_SpriteMediaSpriteIDToIndex, 1,
-	 "(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv, short spriteIndex)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv, short spriteIndex)")},
 	{"SpriteMediaSetActionVariable", (PyCFunction)Qt_SpriteMediaSetActionVariable, 1,
-	 "(MediaHandler mh, QTAtomID variableID, float value) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID variableID, float value) -> (ComponentResult _rv)")},
 	{"SpriteMediaGetActionVariable", (PyCFunction)Qt_SpriteMediaGetActionVariable, 1,
-	 "(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, float value)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, float value)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"SpriteMediaGetIndImageProperty", (PyCFunction)Qt_SpriteMediaGetIndImageProperty, 1,
-	 "(MediaHandler mh, short imageIndex, long imagePropertyType, void * imagePropertyValue) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, short imageIndex, long imagePropertyType, void * imagePropertyValue) -> (ComponentResult _rv)")},
 #endif
 	{"SpriteMediaDisposeSprite", (PyCFunction)Qt_SpriteMediaDisposeSprite, 1,
-	 "(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID spriteID) -> (ComponentResult _rv)")},
 	{"SpriteMediaSetActionVariableToString", (PyCFunction)Qt_SpriteMediaSetActionVariableToString, 1,
-	 "(MediaHandler mh, QTAtomID variableID, Ptr theCString) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID variableID, Ptr theCString) -> (ComponentResult _rv)")},
 	{"SpriteMediaGetActionVariableAsString", (PyCFunction)Qt_SpriteMediaGetActionVariableAsString, 1,
-	 "(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, Handle theCString)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID variableID) -> (ComponentResult _rv, Handle theCString)")},
 	{"FlashMediaSetPan", (PyCFunction)Qt_FlashMediaSetPan, 1,
-	 "(MediaHandler mh, short xPercent, short yPercent) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, short xPercent, short yPercent) -> (ComponentResult _rv)")},
 	{"FlashMediaSetZoom", (PyCFunction)Qt_FlashMediaSetZoom, 1,
-	 "(MediaHandler mh, short factor) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, short factor) -> (ComponentResult _rv)")},
 	{"FlashMediaSetZoomRect", (PyCFunction)Qt_FlashMediaSetZoomRect, 1,
-	 "(MediaHandler mh, long left, long top, long right, long bottom) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, long left, long top, long right, long bottom) -> (ComponentResult _rv)")},
 	{"FlashMediaGetRefConBounds", (PyCFunction)Qt_FlashMediaGetRefConBounds, 1,
-	 "(MediaHandler mh, long refCon) -> (ComponentResult _rv, long left, long top, long right, long bottom)"},
+	 PyDoc_STR("(MediaHandler mh, long refCon) -> (ComponentResult _rv, long left, long top, long right, long bottom)")},
 	{"FlashMediaGetRefConID", (PyCFunction)Qt_FlashMediaGetRefConID, 1,
-	 "(MediaHandler mh, long refCon) -> (ComponentResult _rv, long refConID)"},
+	 PyDoc_STR("(MediaHandler mh, long refCon) -> (ComponentResult _rv, long refConID)")},
 	{"FlashMediaIDToRefCon", (PyCFunction)Qt_FlashMediaIDToRefCon, 1,
-	 "(MediaHandler mh, long refConID) -> (ComponentResult _rv, long refCon)"},
+	 PyDoc_STR("(MediaHandler mh, long refConID) -> (ComponentResult _rv, long refCon)")},
 	{"FlashMediaGetDisplayedFrameNumber", (PyCFunction)Qt_FlashMediaGetDisplayedFrameNumber, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv, long flashFrameNumber)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, long flashFrameNumber)")},
 	{"FlashMediaFrameNumberToMovieTime", (PyCFunction)Qt_FlashMediaFrameNumberToMovieTime, 1,
-	 "(MediaHandler mh, long flashFrameNumber) -> (ComponentResult _rv, TimeValue movieTime)"},
+	 PyDoc_STR("(MediaHandler mh, long flashFrameNumber) -> (ComponentResult _rv, TimeValue movieTime)")},
 	{"FlashMediaFrameLabelToMovieTime", (PyCFunction)Qt_FlashMediaFrameLabelToMovieTime, 1,
-	 "(MediaHandler mh, Ptr theLabel) -> (ComponentResult _rv, TimeValue movieTime)"},
+	 PyDoc_STR("(MediaHandler mh, Ptr theLabel) -> (ComponentResult _rv, TimeValue movieTime)")},
 	{"FlashMediaGetFlashVariable", (PyCFunction)Qt_FlashMediaGetFlashVariable, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv, char path, char name, Handle theVariableCStringOut)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, char path, char name, Handle theVariableCStringOut)")},
 	{"FlashMediaSetFlashVariable", (PyCFunction)Qt_FlashMediaSetFlashVariable, 1,
-	 "(MediaHandler mh, Boolean updateFocus) -> (ComponentResult _rv, char path, char name, char value)"},
+	 PyDoc_STR("(MediaHandler mh, Boolean updateFocus) -> (ComponentResult _rv, char path, char name, char value)")},
 	{"FlashMediaDoButtonActions", (PyCFunction)Qt_FlashMediaDoButtonActions, 1,
-	 "(MediaHandler mh, long buttonID, long transition) -> (ComponentResult _rv, char path)"},
+	 PyDoc_STR("(MediaHandler mh, long buttonID, long transition) -> (ComponentResult _rv, char path)")},
 	{"FlashMediaGetSupportedSwfVersion", (PyCFunction)Qt_FlashMediaGetSupportedSwfVersion, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv, UInt8 swfVersion)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, UInt8 swfVersion)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"MovieMediaGetCurrentMovieProperty", (PyCFunction)Qt_MovieMediaGetCurrentMovieProperty, 1,
-	 "(MediaHandler mh, OSType whichProperty, void * value) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, OSType whichProperty, void * value) -> (ComponentResult _rv)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"MovieMediaGetCurrentTrackProperty", (PyCFunction)Qt_MovieMediaGetCurrentTrackProperty, 1,
-	 "(MediaHandler mh, long trackID, OSType whichProperty, void * value) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, long trackID, OSType whichProperty, void * value) -> (ComponentResult _rv)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"MovieMediaGetChildMovieDataReference", (PyCFunction)Qt_MovieMediaGetChildMovieDataReference, 1,
-	 "(MediaHandler mh, QTAtomID dataRefID, short dataRefIndex) -> (ComponentResult _rv, OSType dataRefType, Handle dataRef, QTAtomID dataRefIDOut, short dataRefIndexOut)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID dataRefID, short dataRefIndex) -> (ComponentResult _rv, OSType dataRefType, Handle dataRef, QTAtomID dataRefIDOut, short dataRefIndexOut)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"MovieMediaSetChildMovieDataReference", (PyCFunction)Qt_MovieMediaSetChildMovieDataReference, 1,
-	 "(MediaHandler mh, QTAtomID dataRefID, OSType dataRefType, Handle dataRef) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID dataRefID, OSType dataRefType, Handle dataRef) -> (ComponentResult _rv)")},
 #endif
 
 #if !TARGET_API_MAC_CARBON
 	{"MovieMediaLoadChildMovieFromDataReference", (PyCFunction)Qt_MovieMediaLoadChildMovieFromDataReference, 1,
-	 "(MediaHandler mh, QTAtomID dataRefID) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, QTAtomID dataRefID) -> (ComponentResult _rv)")},
 #endif
 	{"Media3DGetCurrentGroup", (PyCFunction)Qt_Media3DGetCurrentGroup, 1,
-	 "(MediaHandler mh, void * group) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, void * group) -> (ComponentResult _rv)")},
 	{"Media3DTranslateNamedObjectTo", (PyCFunction)Qt_Media3DTranslateNamedObjectTo, 1,
-	 "(MediaHandler mh, Fixed x, Fixed y, Fixed z) -> (ComponentResult _rv, char objectName)"},
+	 PyDoc_STR("(MediaHandler mh, Fixed x, Fixed y, Fixed z) -> (ComponentResult _rv, char objectName)")},
 	{"Media3DScaleNamedObjectTo", (PyCFunction)Qt_Media3DScaleNamedObjectTo, 1,
-	 "(MediaHandler mh, Fixed xScale, Fixed yScale, Fixed zScale) -> (ComponentResult _rv, char objectName)"},
+	 PyDoc_STR("(MediaHandler mh, Fixed xScale, Fixed yScale, Fixed zScale) -> (ComponentResult _rv, char objectName)")},
 	{"Media3DRotateNamedObjectTo", (PyCFunction)Qt_Media3DRotateNamedObjectTo, 1,
-	 "(MediaHandler mh, Fixed xDegrees, Fixed yDegrees, Fixed zDegrees) -> (ComponentResult _rv, char objectName)"},
+	 PyDoc_STR("(MediaHandler mh, Fixed xDegrees, Fixed yDegrees, Fixed zDegrees) -> (ComponentResult _rv, char objectName)")},
 	{"Media3DSetCameraData", (PyCFunction)Qt_Media3DSetCameraData, 1,
-	 "(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)")},
 	{"Media3DGetCameraData", (PyCFunction)Qt_Media3DGetCameraData, 1,
-	 "(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, void * cameraData) -> (ComponentResult _rv)")},
 	{"Media3DSetCameraAngleAspect", (PyCFunction)Qt_Media3DSetCameraAngleAspect, 1,
-	 "(MediaHandler mh, QTFloatSingle fov, QTFloatSingle aspectRatioXToY) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, QTFloatSingle fov, QTFloatSingle aspectRatioXToY) -> (ComponentResult _rv)")},
 	{"Media3DGetCameraAngleAspect", (PyCFunction)Qt_Media3DGetCameraAngleAspect, 1,
-	 "(MediaHandler mh) -> (ComponentResult _rv, QTFloatSingle fov, QTFloatSingle aspectRatioXToY)"},
+	 PyDoc_STR("(MediaHandler mh) -> (ComponentResult _rv, QTFloatSingle fov, QTFloatSingle aspectRatioXToY)")},
 	{"Media3DSetCameraRange", (PyCFunction)Qt_Media3DSetCameraRange, 1,
-	 "(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)")},
 	{"Media3DGetCameraRange", (PyCFunction)Qt_Media3DGetCameraRange, 1,
-	 "(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, void * tQ3CameraRange) -> (ComponentResult _rv)")},
 
 #if !TARGET_API_MAC_CARBON
 	{"Media3DGetViewObject", (PyCFunction)Qt_Media3DGetViewObject, 1,
-	 "(MediaHandler mh, void * tq3viewObject) -> (ComponentResult _rv)"},
+	 PyDoc_STR("(MediaHandler mh, void * tq3viewObject) -> (ComponentResult _rv)")},
 #endif
 	{"NewTimeBase", (PyCFunction)Qt_NewTimeBase, 1,
-	 "() -> (TimeBase _rv)"},
+	 PyDoc_STR("() -> (TimeBase _rv)")},
 	{"ConvertTime", (PyCFunction)Qt_ConvertTime, 1,
-	 "(TimeBase newBase) -> (TimeRecord theTime)"},
+	 PyDoc_STR("(TimeBase newBase) -> (TimeRecord theTime)")},
 	{"ConvertTimeScale", (PyCFunction)Qt_ConvertTimeScale, 1,
-	 "(TimeScale newScale) -> (TimeRecord theTime)"},
+	 PyDoc_STR("(TimeScale newScale) -> (TimeRecord theTime)")},
 	{"AddTime", (PyCFunction)Qt_AddTime, 1,
-	 "(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)"},
+	 PyDoc_STR("(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)")},
 	{"SubtractTime", (PyCFunction)Qt_SubtractTime, 1,
-	 "(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)"},
+	 PyDoc_STR("(TimeRecord dst, TimeRecord src) -> (TimeRecord dst)")},
 	{"MusicMediaGetIndexedTunePlayer", (PyCFunction)Qt_MusicMediaGetIndexedTunePlayer, 1,
-	 "(ComponentInstance ti, long sampleDescIndex) -> (ComponentResult _rv, ComponentInstance tp)"},
+	 PyDoc_STR("(ComponentInstance ti, long sampleDescIndex) -> (ComponentResult _rv, ComponentInstance tp)")},
 	{"AlignWindow", (PyCFunction)Qt_AlignWindow, 1,
-	 "(WindowPtr wp, Boolean front) -> None"},
+	 PyDoc_STR("(WindowPtr wp, Boolean front) -> None")},
 	{"DragAlignedWindow", (PyCFunction)Qt_DragAlignedWindow, 1,
-	 "(WindowPtr wp, Point startPt, Rect boundsRect) -> None"},
+	 PyDoc_STR("(WindowPtr wp, Point startPt, Rect boundsRect) -> None")},
 	{"MoviesTask", (PyCFunction)Qt_MoviesTask, 1,
-	 "(long maxMilliSecToUse) -> None"},
+	 PyDoc_STR("(long maxMilliSecToUse) -> None")},
 	{NULL, NULL, 0}
 };