From 49931887d7e135190fbcf0119e03419a7101ff7c Mon Sep 17 00:00:00 2001 From: Jack Jansen Date: Fri, 16 Aug 2002 09:09:31 +0000 Subject: Regenerated with PyDoc_STR() around docstrings. --- Mac/Modules/ae/_AEmodule.c | 92 ++-- Mac/Modules/app/_Appmodule.c | 134 ++--- Mac/Modules/carbonevt/_CarbonEvtmodule.c | 118 ++--- Mac/Modules/cf/_CFmodule.c | 304 ++++++------ Mac/Modules/cg/_CGmodule.c | 118 ++--- Mac/Modules/cm/_Cmmodule.c | 64 +-- Mac/Modules/ctl/_Ctlmodule.c | 452 ++++++++--------- Mac/Modules/dlg/_Dlgmodule.c | 114 ++--- Mac/Modules/drag/_Dragmodule.c | 72 +-- Mac/Modules/evt/_Evtmodule.c | 64 +-- Mac/Modules/fm/_Fmmodule.c | 36 +- Mac/Modules/help/_Helpmodule.c | 30 +- Mac/Modules/ibcarbon/_IBCarbon.c | 10 +- Mac/Modules/icn/_Icnmodule.c | 122 ++--- Mac/Modules/list/_Listmodule.c | 92 ++-- Mac/Modules/menu/_Menumodule.c | 332 ++++++------- Mac/Modules/qd/_Qdmodule.c | 630 ++++++++++++------------ Mac/Modules/qdoffs/_Qdoffsmodule.c | 52 +- Mac/Modules/qt/_Qtmodule.c | 810 +++++++++++++++---------------- Mac/Modules/res/_Resmodule.c | 134 ++--- Mac/Modules/snd/_Sndmodule.c | 98 ++-- Mac/Modules/te/_TEmodule.c | 100 ++-- Mac/Modules/win/_Winmodule.c | 324 ++++++------- 23 files changed, 2151 insertions(+), 2151 deletions(-) diff --git a/Mac/Modules/ae/_AEmodule.c b/Mac/Modules/ae/_AEmodule.c index 38c6bae..0d8b802 100644 --- a/Mac/Modules/ae/_AEmodule.c +++ b/Mac/Modules/ae/_AEmodule.c @@ -759,64 +759,64 @@ static PyObject *AEDesc_AEResolve(AEDescObject *_self, PyObject *_args) static PyMethodDef AEDesc_methods[] = { {"AECoerceDesc", (PyCFunction)AEDesc_AECoerceDesc, 1, - "(DescType toType) -> (AEDesc result)"}, + PyDoc_STR("(DescType toType) -> (AEDesc result)")}, {"AEDuplicateDesc", (PyCFunction)AEDesc_AEDuplicateDesc, 1, - "() -> (AEDesc result)"}, + PyDoc_STR("() -> (AEDesc result)")}, {"AECountItems", (PyCFunction)AEDesc_AECountItems, 1, - "() -> (long theCount)"}, + PyDoc_STR("() -> (long theCount)")}, {"AEPutPtr", (PyCFunction)AEDesc_AEPutPtr, 1, - "(long index, DescType typeCode, Buffer dataPtr) -> None"}, + PyDoc_STR("(long index, DescType typeCode, Buffer dataPtr) -> None")}, {"AEPutDesc", (PyCFunction)AEDesc_AEPutDesc, 1, - "(long index, AEDesc theAEDesc) -> None"}, + PyDoc_STR("(long index, AEDesc theAEDesc) -> None")}, {"AEGetNthPtr", (PyCFunction)AEDesc_AEGetNthPtr, 1, - "(long index, DescType desiredType, Buffer dataPtr) -> (AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr)"}, + PyDoc_STR("(long index, DescType desiredType, Buffer dataPtr) -> (AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr)")}, {"AEGetNthDesc", (PyCFunction)AEDesc_AEGetNthDesc, 1, - "(long index, DescType desiredType) -> (AEKeyword theAEKeyword, AEDesc result)"}, + PyDoc_STR("(long index, DescType desiredType) -> (AEKeyword theAEKeyword, AEDesc result)")}, {"AESizeOfNthItem", (PyCFunction)AEDesc_AESizeOfNthItem, 1, - "(long index) -> (DescType typeCode, Size dataSize)"}, + PyDoc_STR("(long index) -> (DescType typeCode, Size dataSize)")}, {"AEDeleteItem", (PyCFunction)AEDesc_AEDeleteItem, 1, - "(long index) -> None"}, + PyDoc_STR("(long index) -> None")}, {"AEPutParamPtr", (PyCFunction)AEDesc_AEPutParamPtr, 1, - "(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None"}, + PyDoc_STR("(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None")}, {"AEPutParamDesc", (PyCFunction)AEDesc_AEPutParamDesc, 1, - "(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None"}, + PyDoc_STR("(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None")}, {"AEGetParamPtr", (PyCFunction)AEDesc_AEGetParamPtr, 1, - "(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)"}, + PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)")}, {"AEGetParamDesc", (PyCFunction)AEDesc_AEGetParamDesc, 1, - "(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)"}, + PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)")}, {"AESizeOfParam", (PyCFunction)AEDesc_AESizeOfParam, 1, - "(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)"}, + PyDoc_STR("(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)")}, {"AEDeleteParam", (PyCFunction)AEDesc_AEDeleteParam, 1, - "(AEKeyword theAEKeyword) -> None"}, + PyDoc_STR("(AEKeyword theAEKeyword) -> None")}, {"AEGetAttributePtr", (PyCFunction)AEDesc_AEGetAttributePtr, 1, - "(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)"}, + PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)")}, {"AEGetAttributeDesc", (PyCFunction)AEDesc_AEGetAttributeDesc, 1, - "(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)"}, + PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)")}, {"AESizeOfAttribute", (PyCFunction)AEDesc_AESizeOfAttribute, 1, - "(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)"}, + PyDoc_STR("(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)")}, {"AEPutAttributePtr", (PyCFunction)AEDesc_AEPutAttributePtr, 1, - "(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None"}, + PyDoc_STR("(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None")}, {"AEPutAttributeDesc", (PyCFunction)AEDesc_AEPutAttributeDesc, 1, - "(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None"}, + PyDoc_STR("(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None")}, #if TARGET_API_MAC_CARBON {"AEGetDescDataSize", (PyCFunction)AEDesc_AEGetDescDataSize, 1, - "() -> (Size _rv)"}, + PyDoc_STR("() -> (Size _rv)")}, #endif {"AESend", (PyCFunction)AEDesc_AESend, 1, - "(AESendMode sendMode, AESendPriority sendPriority, long timeOutInTicks) -> (AppleEvent reply)"}, + PyDoc_STR("(AESendMode sendMode, AESendPriority sendPriority, long timeOutInTicks) -> (AppleEvent reply)")}, {"AEResetTimer", (PyCFunction)AEDesc_AEResetTimer, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"AESuspendTheCurrentEvent", (PyCFunction)AEDesc_AESuspendTheCurrentEvent, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"AEResumeTheCurrentEvent", (PyCFunction)AEDesc_AEResumeTheCurrentEvent, 1, - "(AppleEvent reply, EventHandler dispatcher) -> None"}, + PyDoc_STR("(AppleEvent reply, EventHandler dispatcher) -> None")}, {"AEGetTheCurrentEvent", (PyCFunction)AEDesc_AEGetTheCurrentEvent, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"AESetTheCurrentEvent", (PyCFunction)AEDesc_AESetTheCurrentEvent, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"AEResolve", (PyCFunction)AEDesc_AEResolve, 1, - "(short callbackFlags) -> (AEDesc theToken)"}, + PyDoc_STR("(short callbackFlags) -> (AEDesc theToken)")}, {NULL, NULL, 0} }; @@ -1307,44 +1307,44 @@ static PyObject *AE_AECallObjectAccessor(PyObject *_self, PyObject *_args) static PyMethodDef AE_methods[] = { {"AECoercePtr", (PyCFunction)AE_AECoercePtr, 1, - "(DescType typeCode, Buffer dataPtr, DescType toType) -> (AEDesc result)"}, + PyDoc_STR("(DescType typeCode, Buffer dataPtr, DescType toType) -> (AEDesc result)")}, {"AECreateDesc", (PyCFunction)AE_AECreateDesc, 1, - "(DescType typeCode, Buffer dataPtr) -> (AEDesc result)"}, + PyDoc_STR("(DescType typeCode, Buffer dataPtr) -> (AEDesc result)")}, {"AECreateList", (PyCFunction)AE_AECreateList, 1, - "(Buffer factoringPtr, Boolean isRecord) -> (AEDescList resultList)"}, + PyDoc_STR("(Buffer factoringPtr, Boolean isRecord) -> (AEDescList resultList)")}, {"AECreateAppleEvent", (PyCFunction)AE_AECreateAppleEvent, 1, - "(AEEventClass theAEEventClass, AEEventID theAEEventID, AEAddressDesc target, AEReturnID returnID, AETransactionID transactionID) -> (AppleEvent result)"}, + PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID, AEAddressDesc target, AEReturnID returnID, AETransactionID transactionID) -> (AppleEvent result)")}, #if TARGET_API_MAC_CARBON {"AEReplaceDescData", (PyCFunction)AE_AEReplaceDescData, 1, - "(DescType typeCode, Buffer dataPtr) -> (AEDesc theAEDesc)"}, + PyDoc_STR("(DescType typeCode, Buffer dataPtr) -> (AEDesc theAEDesc)")}, #endif {"AEProcessAppleEvent", (PyCFunction)AE_AEProcessAppleEvent, 1, - "(EventRecord theEventRecord) -> None"}, + PyDoc_STR("(EventRecord theEventRecord) -> None")}, {"AEGetInteractionAllowed", (PyCFunction)AE_AEGetInteractionAllowed, 1, - "() -> (AEInteractAllowed level)"}, + PyDoc_STR("() -> (AEInteractAllowed level)")}, {"AESetInteractionAllowed", (PyCFunction)AE_AESetInteractionAllowed, 1, - "(AEInteractAllowed level) -> None"}, + PyDoc_STR("(AEInteractAllowed level) -> None")}, {"AEInteractWithUser", (PyCFunction)AE_AEInteractWithUser, 1, - "(long timeOutInTicks) -> None"}, + PyDoc_STR("(long timeOutInTicks) -> None")}, {"AEInstallEventHandler", (PyCFunction)AE_AEInstallEventHandler, 1, - "(AEEventClass theAEEventClass, AEEventID theAEEventID, EventHandler handler) -> None"}, + PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID, EventHandler handler) -> None")}, {"AERemoveEventHandler", (PyCFunction)AE_AERemoveEventHandler, 1, - "(AEEventClass theAEEventClass, AEEventID theAEEventID) -> None"}, + PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID) -> None")}, {"AEGetEventHandler", (PyCFunction)AE_AEGetEventHandler, 1, - "(AEEventClass theAEEventClass, AEEventID theAEEventID) -> (EventHandler handler)"}, + PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID) -> (EventHandler handler)")}, {"AEInstallSpecialHandler", (PyCFunction)AE_AEInstallSpecialHandler, 1, - "(AEKeyword functionClass) -> None"}, + PyDoc_STR("(AEKeyword functionClass) -> None")}, {"AERemoveSpecialHandler", (PyCFunction)AE_AERemoveSpecialHandler, 1, - "(AEKeyword functionClass) -> None"}, + PyDoc_STR("(AEKeyword functionClass) -> None")}, {"AEManagerInfo", (PyCFunction)AE_AEManagerInfo, 1, - "(AEKeyword keyWord) -> (long result)"}, + PyDoc_STR("(AEKeyword keyWord) -> (long result)")}, {"AEObjectInit", (PyCFunction)AE_AEObjectInit, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"AEDisposeToken", (PyCFunction)AE_AEDisposeToken, 1, - "() -> (AEDesc theToken)"}, + PyDoc_STR("() -> (AEDesc theToken)")}, {"AECallObjectAccessor", (PyCFunction)AE_AECallObjectAccessor, 1, - "(DescType desiredClass, AEDesc containerToken, DescType containerClass, DescType keyForm, AEDesc keyData) -> (AEDesc token)"}, + PyDoc_STR("(DescType desiredClass, AEDesc containerToken, DescType containerClass, DescType keyForm, AEDesc keyData) -> (AEDesc token)")}, {NULL, NULL, 0} }; diff --git a/Mac/Modules/app/_Appmodule.c b/Mac/Modules/app/_Appmodule.c index d853927..e5362c9 100644 --- a/Mac/Modules/app/_Appmodule.c +++ b/Mac/Modules/app/_Appmodule.c @@ -107,9 +107,9 @@ static PyObject *ThemeDrawingStateObj_DisposeThemeDrawingState(ThemeDrawingState static PyMethodDef ThemeDrawingStateObj_methods[] = { {"SetThemeDrawingState", (PyCFunction)ThemeDrawingStateObj_SetThemeDrawingState, 1, - "(Boolean inDisposeNow) -> (OSStatus _rv)"}, + PyDoc_STR("(Boolean inDisposeNow) -> (OSStatus _rv)")}, {"DisposeThemeDrawingState", (PyCFunction)ThemeDrawingStateObj_DisposeThemeDrawingState, 1, - "() -> (OSStatus _rv)"}, + PyDoc_STR("() -> (OSStatus _rv)")}, {NULL, NULL, 0} }; @@ -1646,149 +1646,149 @@ static PyObject *App_GetThemeMetric(PyObject *_self, PyObject *_args) static PyMethodDef App_methods[] = { {"RegisterAppearanceClient", (PyCFunction)App_RegisterAppearanceClient, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"UnregisterAppearanceClient", (PyCFunction)App_UnregisterAppearanceClient, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"SetThemePen", (PyCFunction)App_SetThemePen, 1, - "(ThemeBrush inBrush, SInt16 inDepth, Boolean inIsColorDevice) -> None"}, + PyDoc_STR("(ThemeBrush inBrush, SInt16 inDepth, Boolean inIsColorDevice) -> None")}, {"SetThemeBackground", (PyCFunction)App_SetThemeBackground, 1, - "(ThemeBrush inBrush, SInt16 inDepth, Boolean inIsColorDevice) -> None"}, + PyDoc_STR("(ThemeBrush inBrush, SInt16 inDepth, Boolean inIsColorDevice) -> None")}, {"SetThemeTextColor", (PyCFunction)App_SetThemeTextColor, 1, - "(ThemeTextColor inColor, SInt16 inDepth, Boolean inIsColorDevice) -> None"}, + PyDoc_STR("(ThemeTextColor inColor, SInt16 inDepth, Boolean inIsColorDevice) -> None")}, {"SetThemeWindowBackground", (PyCFunction)App_SetThemeWindowBackground, 1, - "(WindowPtr inWindow, ThemeBrush inBrush, Boolean inUpdate) -> None"}, + PyDoc_STR("(WindowPtr inWindow, ThemeBrush inBrush, Boolean inUpdate) -> None")}, {"DrawThemeWindowHeader", (PyCFunction)App_DrawThemeWindowHeader, 1, - "(Rect inRect, ThemeDrawState inState) -> None"}, + PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")}, {"DrawThemeWindowListViewHeader", (PyCFunction)App_DrawThemeWindowListViewHeader, 1, - "(Rect inRect, ThemeDrawState inState) -> None"}, + PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")}, {"DrawThemePlacard", (PyCFunction)App_DrawThemePlacard, 1, - "(Rect inRect, ThemeDrawState inState) -> None"}, + PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")}, {"DrawThemeEditTextFrame", (PyCFunction)App_DrawThemeEditTextFrame, 1, - "(Rect inRect, ThemeDrawState inState) -> None"}, + PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")}, {"DrawThemeListBoxFrame", (PyCFunction)App_DrawThemeListBoxFrame, 1, - "(Rect inRect, ThemeDrawState inState) -> None"}, + PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")}, {"DrawThemeFocusRect", (PyCFunction)App_DrawThemeFocusRect, 1, - "(Rect inRect, Boolean inHasFocus) -> None"}, + PyDoc_STR("(Rect inRect, Boolean inHasFocus) -> None")}, {"DrawThemePrimaryGroup", (PyCFunction)App_DrawThemePrimaryGroup, 1, - "(Rect inRect, ThemeDrawState inState) -> None"}, + PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")}, {"DrawThemeSecondaryGroup", (PyCFunction)App_DrawThemeSecondaryGroup, 1, - "(Rect inRect, ThemeDrawState inState) -> None"}, + PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")}, {"DrawThemeSeparator", (PyCFunction)App_DrawThemeSeparator, 1, - "(Rect inRect, ThemeDrawState inState) -> None"}, + PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")}, {"DrawThemeModelessDialogFrame", (PyCFunction)App_DrawThemeModelessDialogFrame, 1, - "(Rect inRect, ThemeDrawState inState) -> None"}, + PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")}, {"DrawThemeGenericWell", (PyCFunction)App_DrawThemeGenericWell, 1, - "(Rect inRect, ThemeDrawState inState, Boolean inFillCenter) -> None"}, + PyDoc_STR("(Rect inRect, ThemeDrawState inState, Boolean inFillCenter) -> None")}, {"DrawThemeFocusRegion", (PyCFunction)App_DrawThemeFocusRegion, 1, - "(Boolean inHasFocus) -> None"}, + PyDoc_STR("(Boolean inHasFocus) -> None")}, {"IsThemeInColor", (PyCFunction)App_IsThemeInColor, 1, - "(SInt16 inDepth, Boolean inIsColorDevice) -> (Boolean _rv)"}, + PyDoc_STR("(SInt16 inDepth, Boolean inIsColorDevice) -> (Boolean _rv)")}, {"GetThemeAccentColors", (PyCFunction)App_GetThemeAccentColors, 1, - "() -> (CTabHandle outColors)"}, + PyDoc_STR("() -> (CTabHandle outColors)")}, {"DrawThemeMenuBarBackground", (PyCFunction)App_DrawThemeMenuBarBackground, 1, - "(Rect inBounds, ThemeMenuBarState inState, UInt32 inAttributes) -> None"}, + PyDoc_STR("(Rect inBounds, ThemeMenuBarState inState, UInt32 inAttributes) -> None")}, {"GetThemeMenuBarHeight", (PyCFunction)App_GetThemeMenuBarHeight, 1, - "() -> (SInt16 outHeight)"}, + PyDoc_STR("() -> (SInt16 outHeight)")}, {"DrawThemeMenuBackground", (PyCFunction)App_DrawThemeMenuBackground, 1, - "(Rect inMenuRect, ThemeMenuType inMenuType) -> None"}, + PyDoc_STR("(Rect inMenuRect, ThemeMenuType inMenuType) -> None")}, {"GetThemeMenuBackgroundRegion", (PyCFunction)App_GetThemeMenuBackgroundRegion, 1, - "(Rect inMenuRect, ThemeMenuType menuType) -> None"}, + PyDoc_STR("(Rect inMenuRect, ThemeMenuType menuType) -> None")}, {"DrawThemeMenuSeparator", (PyCFunction)App_DrawThemeMenuSeparator, 1, - "(Rect inItemRect) -> None"}, + PyDoc_STR("(Rect inItemRect) -> None")}, {"GetThemeMenuSeparatorHeight", (PyCFunction)App_GetThemeMenuSeparatorHeight, 1, - "() -> (SInt16 outHeight)"}, + PyDoc_STR("() -> (SInt16 outHeight)")}, {"GetThemeMenuItemExtra", (PyCFunction)App_GetThemeMenuItemExtra, 1, - "(ThemeMenuItemType inItemType) -> (SInt16 outHeight, SInt16 outWidth)"}, + PyDoc_STR("(ThemeMenuItemType inItemType) -> (SInt16 outHeight, SInt16 outWidth)")}, {"GetThemeMenuTitleExtra", (PyCFunction)App_GetThemeMenuTitleExtra, 1, - "(Boolean inIsSquished) -> (SInt16 outWidth)"}, + PyDoc_STR("(Boolean inIsSquished) -> (SInt16 outWidth)")}, {"DrawThemeTabPane", (PyCFunction)App_DrawThemeTabPane, 1, - "(Rect inRect, ThemeDrawState inState) -> None"}, + PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")}, {"GetThemeTabRegion", (PyCFunction)App_GetThemeTabRegion, 1, - "(Rect inRect, ThemeTabStyle inStyle, ThemeTabDirection inDirection) -> None"}, + PyDoc_STR("(Rect inRect, ThemeTabStyle inStyle, ThemeTabDirection inDirection) -> None")}, {"SetThemeCursor", (PyCFunction)App_SetThemeCursor, 1, - "(ThemeCursor inCursor) -> None"}, + PyDoc_STR("(ThemeCursor inCursor) -> None")}, {"SetAnimatedThemeCursor", (PyCFunction)App_SetAnimatedThemeCursor, 1, - "(ThemeCursor inCursor, UInt32 inAnimationStep) -> None"}, + PyDoc_STR("(ThemeCursor inCursor, UInt32 inAnimationStep) -> None")}, {"GetThemeScrollBarThumbStyle", (PyCFunction)App_GetThemeScrollBarThumbStyle, 1, - "() -> (ThemeScrollBarThumbStyle outStyle)"}, + PyDoc_STR("() -> (ThemeScrollBarThumbStyle outStyle)")}, {"GetThemeScrollBarArrowStyle", (PyCFunction)App_GetThemeScrollBarArrowStyle, 1, - "() -> (ThemeScrollBarArrowStyle outStyle)"}, + PyDoc_STR("() -> (ThemeScrollBarArrowStyle outStyle)")}, {"GetThemeCheckBoxStyle", (PyCFunction)App_GetThemeCheckBoxStyle, 1, - "() -> (ThemeCheckBoxStyle outStyle)"}, + PyDoc_STR("() -> (ThemeCheckBoxStyle outStyle)")}, {"UseThemeFont", (PyCFunction)App_UseThemeFont, 1, - "(ThemeFontID inFontID, ScriptCode inScript) -> None"}, + PyDoc_STR("(ThemeFontID inFontID, ScriptCode inScript) -> None")}, #if TARGET_API_MAC_CARBON {"DrawThemeTextBox", (PyCFunction)App_DrawThemeTextBox, 1, - "(CFStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, Boolean inWrapToWidth, Rect inBoundingBox, SInt16 inJust) -> None"}, + PyDoc_STR("(CFStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, Boolean inWrapToWidth, Rect inBoundingBox, SInt16 inJust) -> None")}, #endif #if TARGET_API_MAC_CARBON {"TruncateThemeText", (PyCFunction)App_TruncateThemeText, 1, - "(CFMutableStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, SInt16 inPixelWidthLimit, TruncCode inTruncWhere) -> (Boolean outTruncated)"}, + PyDoc_STR("(CFMutableStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, SInt16 inPixelWidthLimit, TruncCode inTruncWhere) -> (Boolean outTruncated)")}, #endif #if TARGET_API_MAC_CARBON {"GetThemeTextDimensions", (PyCFunction)App_GetThemeTextDimensions, 1, - "(CFStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, Boolean inWrapToWidth, Point ioBounds) -> (Point ioBounds, SInt16 outBaseline)"}, + PyDoc_STR("(CFStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, Boolean inWrapToWidth, Point ioBounds) -> (Point ioBounds, SInt16 outBaseline)")}, #endif #if TARGET_API_MAC_CARBON {"GetThemeTextShadowOutset", (PyCFunction)App_GetThemeTextShadowOutset, 1, - "(ThemeFontID inFontID, ThemeDrawState inState) -> (Rect outOutset)"}, + PyDoc_STR("(ThemeFontID inFontID, ThemeDrawState inState) -> (Rect outOutset)")}, #endif {"DrawThemeScrollBarArrows", (PyCFunction)App_DrawThemeScrollBarArrows, 1, - "(Rect bounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz) -> (Rect trackBounds)"}, + PyDoc_STR("(Rect bounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz) -> (Rect trackBounds)")}, {"GetThemeScrollBarTrackRect", (PyCFunction)App_GetThemeScrollBarTrackRect, 1, - "(Rect bounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz) -> (Rect trackBounds)"}, + PyDoc_STR("(Rect bounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz) -> (Rect trackBounds)")}, {"HitTestThemeScrollBarArrows", (PyCFunction)App_HitTestThemeScrollBarArrows, 1, - "(Rect scrollBarBounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz, Point ptHit) -> (Boolean _rv, Rect trackBounds, ControlPartCode partcode)"}, + PyDoc_STR("(Rect scrollBarBounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz, Point ptHit) -> (Boolean _rv, Rect trackBounds, ControlPartCode partcode)")}, {"DrawThemeScrollBarDelimiters", (PyCFunction)App_DrawThemeScrollBarDelimiters, 1, - "(ThemeWindowType flavor, Rect inContRect, ThemeDrawState state, ThemeWindowAttributes attributes) -> None"}, + PyDoc_STR("(ThemeWindowType flavor, Rect inContRect, ThemeDrawState state, ThemeWindowAttributes attributes) -> None")}, {"DrawThemeButton", (PyCFunction)App_DrawThemeButton, 1, - "(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inNewInfo, ThemeButtonDrawInfo inPrevInfo, UInt32 inUserData) -> None"}, + PyDoc_STR("(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inNewInfo, ThemeButtonDrawInfo inPrevInfo, UInt32 inUserData) -> None")}, {"GetThemeButtonRegion", (PyCFunction)App_GetThemeButtonRegion, 1, - "(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inNewInfo) -> None"}, + PyDoc_STR("(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inNewInfo) -> None")}, {"GetThemeButtonContentBounds", (PyCFunction)App_GetThemeButtonContentBounds, 1, - "(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inDrawInfo) -> (Rect outBounds)"}, + PyDoc_STR("(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inDrawInfo) -> (Rect outBounds)")}, {"GetThemeButtonBackgroundBounds", (PyCFunction)App_GetThemeButtonBackgroundBounds, 1, - "(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inDrawInfo) -> (Rect outBounds)"}, + PyDoc_STR("(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inDrawInfo) -> (Rect outBounds)")}, {"PlayThemeSound", (PyCFunction)App_PlayThemeSound, 1, - "(ThemeSoundKind kind) -> None"}, + PyDoc_STR("(ThemeSoundKind kind) -> None")}, {"BeginThemeDragSound", (PyCFunction)App_BeginThemeDragSound, 1, - "(ThemeDragSoundKind kind) -> None"}, + PyDoc_STR("(ThemeDragSoundKind kind) -> None")}, {"EndThemeDragSound", (PyCFunction)App_EndThemeDragSound, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"DrawThemeTickMark", (PyCFunction)App_DrawThemeTickMark, 1, - "(Rect bounds, ThemeDrawState state) -> None"}, + PyDoc_STR("(Rect bounds, ThemeDrawState state) -> None")}, {"DrawThemeChasingArrows", (PyCFunction)App_DrawThemeChasingArrows, 1, - "(Rect bounds, UInt32 index, ThemeDrawState state, UInt32 eraseData) -> None"}, + PyDoc_STR("(Rect bounds, UInt32 index, ThemeDrawState state, UInt32 eraseData) -> None")}, {"DrawThemePopupArrow", (PyCFunction)App_DrawThemePopupArrow, 1, - "(Rect bounds, ThemeArrowOrientation orientation, ThemePopupArrowSize size, ThemeDrawState state, UInt32 eraseData) -> None"}, + PyDoc_STR("(Rect bounds, ThemeArrowOrientation orientation, ThemePopupArrowSize size, ThemeDrawState state, UInt32 eraseData) -> None")}, {"DrawThemeStandaloneGrowBox", (PyCFunction)App_DrawThemeStandaloneGrowBox, 1, - "(Point origin, ThemeGrowDirection growDirection, Boolean isSmall, ThemeDrawState state) -> None"}, + PyDoc_STR("(Point origin, ThemeGrowDirection growDirection, Boolean isSmall, ThemeDrawState state) -> None")}, {"DrawThemeStandaloneNoGrowBox", (PyCFunction)App_DrawThemeStandaloneNoGrowBox, 1, - "(Point origin, ThemeGrowDirection growDirection, Boolean isSmall, ThemeDrawState state) -> None"}, + PyDoc_STR("(Point origin, ThemeGrowDirection growDirection, Boolean isSmall, ThemeDrawState state) -> None")}, {"GetThemeStandaloneGrowBoxBounds", (PyCFunction)App_GetThemeStandaloneGrowBoxBounds, 1, - "(Point origin, ThemeGrowDirection growDirection, Boolean isSmall) -> (Rect bounds)"}, + PyDoc_STR("(Point origin, ThemeGrowDirection growDirection, Boolean isSmall) -> (Rect bounds)")}, {"NormalizeThemeDrawingState", (PyCFunction)App_NormalizeThemeDrawingState, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"GetThemeDrawingState", (PyCFunction)App_GetThemeDrawingState, 1, - "() -> (ThemeDrawingState outState)"}, + PyDoc_STR("() -> (ThemeDrawingState outState)")}, {"ApplyThemeBackground", (PyCFunction)App_ApplyThemeBackground, 1, - "(ThemeBackgroundKind inKind, Rect bounds, ThemeDrawState inState, SInt16 inDepth, Boolean inColorDev) -> None"}, + PyDoc_STR("(ThemeBackgroundKind inKind, Rect bounds, ThemeDrawState inState, SInt16 inDepth, Boolean inColorDev) -> None")}, {"SetThemeTextColorForWindow", (PyCFunction)App_SetThemeTextColorForWindow, 1, - "(WindowPtr window, Boolean isActive, SInt16 depth, Boolean isColorDev) -> None"}, + PyDoc_STR("(WindowPtr window, Boolean isActive, SInt16 depth, Boolean isColorDev) -> None")}, {"IsValidAppearanceFileType", (PyCFunction)App_IsValidAppearanceFileType, 1, - "(OSType fileType) -> (Boolean _rv)"}, + PyDoc_STR("(OSType fileType) -> (Boolean _rv)")}, {"GetThemeBrushAsColor", (PyCFunction)App_GetThemeBrushAsColor, 1, - "(ThemeBrush inBrush, SInt16 inDepth, Boolean inColorDev) -> (RGBColor outColor)"}, + PyDoc_STR("(ThemeBrush inBrush, SInt16 inDepth, Boolean inColorDev) -> (RGBColor outColor)")}, {"GetThemeTextColor", (PyCFunction)App_GetThemeTextColor, 1, - "(ThemeTextColor inColor, SInt16 inDepth, Boolean inColorDev) -> (RGBColor outColor)"}, + PyDoc_STR("(ThemeTextColor inColor, SInt16 inDepth, Boolean inColorDev) -> (RGBColor outColor)")}, #if TARGET_API_MAC_CARBON {"GetThemeMetric", (PyCFunction)App_GetThemeMetric, 1, - "(ThemeMetric inMetric) -> (SInt32 outMetric)"}, + PyDoc_STR("(ThemeMetric inMetric) -> (SInt32 outMetric)")}, #endif {NULL, NULL, 0} }; diff --git a/Mac/Modules/carbonevt/_CarbonEvtmodule.c b/Mac/Modules/carbonevt/_CarbonEvtmodule.c index 5dce28b..9ef572c 100755 --- a/Mac/Modules/carbonevt/_CarbonEvtmodule.c +++ b/Mac/Modules/carbonevt/_CarbonEvtmodule.c @@ -380,31 +380,31 @@ static PyObject *EventRef_GetEventParameter(EventRefObject *_self, PyObject *_ar static PyMethodDef EventRef_methods[] = { {"RetainEvent", (PyCFunction)EventRef_RetainEvent, 1, - "() -> (EventRef _rv)"}, + PyDoc_STR("() -> (EventRef _rv)")}, {"GetEventRetainCount", (PyCFunction)EventRef_GetEventRetainCount, 1, - "() -> (UInt32 _rv)"}, + PyDoc_STR("() -> (UInt32 _rv)")}, {"ReleaseEvent", (PyCFunction)EventRef_ReleaseEvent, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"SetEventParameter", (PyCFunction)EventRef_SetEventParameter, 1, - "(OSType inName, OSType inType, Buffer inDataPtr) -> None"}, + PyDoc_STR("(OSType inName, OSType inType, Buffer inDataPtr) -> None")}, {"GetEventClass", (PyCFunction)EventRef_GetEventClass, 1, - "() -> (UInt32 _rv)"}, + PyDoc_STR("() -> (UInt32 _rv)")}, {"GetEventKind", (PyCFunction)EventRef_GetEventKind, 1, - "() -> (UInt32 _rv)"}, + PyDoc_STR("() -> (UInt32 _rv)")}, {"GetEventTime", (PyCFunction)EventRef_GetEventTime, 1, - "() -> (double _rv)"}, + PyDoc_STR("() -> (double _rv)")}, {"SetEventTime", (PyCFunction)EventRef_SetEventTime, 1, - "(double inTime) -> None"}, + PyDoc_STR("(double inTime) -> None")}, {"IsUserCancelEventRef", (PyCFunction)EventRef_IsUserCancelEventRef, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, {"ConvertEventRefToEventRecord", (PyCFunction)EventRef_ConvertEventRefToEventRecord, 1, - "() -> (Boolean _rv, EventRecord outEvent)"}, + PyDoc_STR("() -> (Boolean _rv, EventRecord outEvent)")}, {"IsEventInMask", (PyCFunction)EventRef_IsEventInMask, 1, - "(UInt16 inMask) -> (Boolean _rv)"}, + PyDoc_STR("(UInt16 inMask) -> (Boolean _rv)")}, {"SendEventToEventTarget", (PyCFunction)EventRef_SendEventToEventTarget, 1, - "(EventTargetRef inTarget) -> None"}, + PyDoc_STR("(EventTargetRef inTarget) -> None")}, {"GetEventParameter", (PyCFunction)EventRef_GetEventParameter, 1, - "(EventParamName eventName, EventParamType eventType) -> (String eventParamData)"}, + PyDoc_STR("(EventParamName eventName, EventParamType eventType) -> (String eventParamData)")}, {NULL, NULL, 0} }; @@ -577,17 +577,17 @@ static PyObject *EventQueueRef_IsEventInQueue(EventQueueRefObject *_self, PyObje static PyMethodDef EventQueueRef_methods[] = { {"PostEventToQueue", (PyCFunction)EventQueueRef_PostEventToQueue, 1, - "(EventRef inEvent, SInt16 inPriority) -> None"}, + PyDoc_STR("(EventRef inEvent, SInt16 inPriority) -> None")}, {"FlushEventsMatchingListFromQueue", (PyCFunction)EventQueueRef_FlushEventsMatchingListFromQueue, 1, - "(UInt32 inNumTypes, EventTypeSpec inList) -> None"}, + PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")}, {"FlushEventQueue", (PyCFunction)EventQueueRef_FlushEventQueue, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"GetNumEventsInQueue", (PyCFunction)EventQueueRef_GetNumEventsInQueue, 1, - "() -> (UInt32 _rv)"}, + PyDoc_STR("() -> (UInt32 _rv)")}, {"RemoveEventFromQueue", (PyCFunction)EventQueueRef_RemoveEventFromQueue, 1, - "(EventRef inEvent) -> None"}, + PyDoc_STR("(EventRef inEvent) -> None")}, {"IsEventInQueue", (PyCFunction)EventQueueRef_IsEventInQueue, 1, - "(EventRef inEvent) -> (Boolean _rv)"}, + PyDoc_STR("(EventRef inEvent) -> (Boolean _rv)")}, {NULL, NULL, 0} }; @@ -679,7 +679,7 @@ static PyObject *EventLoopRef_QuitEventLoop(EventLoopRefObject *_self, PyObject static PyMethodDef EventLoopRef_methods[] = { {"QuitEventLoop", (PyCFunction)EventLoopRef_QuitEventLoop, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {NULL, NULL, 0} }; @@ -787,9 +787,9 @@ static PyObject *EventLoopTimerRef_SetEventLoopTimerNextFireTime(EventLoopTimerR static PyMethodDef EventLoopTimerRef_methods[] = { {"RemoveEventLoopTimer", (PyCFunction)EventLoopTimerRef_RemoveEventLoopTimer, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"SetEventLoopTimerNextFireTime", (PyCFunction)EventLoopTimerRef_SetEventLoopTimerNextFireTime, 1, - "(double inNextFire) -> None"}, + PyDoc_STR("(double inNextFire) -> None")}, {NULL, NULL, 0} }; @@ -940,11 +940,11 @@ static PyObject *EventHandlerRef_RemoveEventHandler(EventHandlerRefObject *_self static PyMethodDef EventHandlerRef_methods[] = { {"AddEventTypesToHandler", (PyCFunction)EventHandlerRef_AddEventTypesToHandler, 1, - "(UInt32 inNumTypes, EventTypeSpec inList) -> None"}, + PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")}, {"RemoveEventTypesFromHandler", (PyCFunction)EventHandlerRef_RemoveEventTypesFromHandler, 1, - "(UInt32 inNumTypes, EventTypeSpec inList) -> None"}, + PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")}, {"RemoveEventHandler", (PyCFunction)EventHandlerRef_RemoveEventHandler, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {NULL, NULL, 0} }; @@ -1039,7 +1039,7 @@ static PyObject *EventHandlerCallRef_CallNextEventHandler(EventHandlerCallRefObj static PyMethodDef EventHandlerCallRef_methods[] = { {"CallNextEventHandler", (PyCFunction)EventHandlerCallRef_CallNextEventHandler, 1, - "(EventRef inEvent) -> None"}, + PyDoc_STR("(EventRef inEvent) -> None")}, {NULL, NULL, 0} }; @@ -1154,9 +1154,9 @@ static PyObject *EventTargetRef_InstallEventHandler(EventTargetRefObject *_self, static PyMethodDef EventTargetRef_methods[] = { {"InstallStandardEventHandler", (PyCFunction)EventTargetRef_InstallStandardEventHandler, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"InstallEventHandler", (PyCFunction)EventTargetRef_InstallEventHandler, 1, - "(EventTypeSpec inSpec, Method callback) -> (EventHandlerRef outRef)"}, + PyDoc_STR("(EventTypeSpec inSpec, Method callback) -> (EventHandlerRef outRef)")}, {NULL, NULL, 0} }; @@ -1248,7 +1248,7 @@ static PyObject *EventHotKeyRef_UnregisterEventHotKey(EventHotKeyRefObject *_sel static PyMethodDef EventHotKeyRef_methods[] = { {"UnregisterEventHotKey", (PyCFunction)EventHotKeyRef_UnregisterEventHotKey, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {NULL, NULL, 0} }; @@ -1778,65 +1778,65 @@ static PyObject *CarbonEvents_RunApplicationEventLoop(PyObject *_self, PyObject static PyMethodDef CarbonEvents_methods[] = { {"GetCurrentEventLoop", (PyCFunction)CarbonEvents_GetCurrentEventLoop, 1, - "() -> (EventLoopRef _rv)"}, + PyDoc_STR("() -> (EventLoopRef _rv)")}, {"GetMainEventLoop", (PyCFunction)CarbonEvents_GetMainEventLoop, 1, - "() -> (EventLoopRef _rv)"}, + PyDoc_STR("() -> (EventLoopRef _rv)")}, {"RunCurrentEventLoop", (PyCFunction)CarbonEvents_RunCurrentEventLoop, 1, - "(double inTimeout) -> None"}, + PyDoc_STR("(double inTimeout) -> None")}, {"ReceiveNextEvent", (PyCFunction)CarbonEvents_ReceiveNextEvent, 1, - "(UInt32 inNumTypes, EventTypeSpec inList, double inTimeout, Boolean inPullEvent) -> (EventRef outEvent)"}, + PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList, double inTimeout, Boolean inPullEvent) -> (EventRef outEvent)")}, {"GetCurrentEventQueue", (PyCFunction)CarbonEvents_GetCurrentEventQueue, 1, - "() -> (EventQueueRef _rv)"}, + PyDoc_STR("() -> (EventQueueRef _rv)")}, {"GetMainEventQueue", (PyCFunction)CarbonEvents_GetMainEventQueue, 1, - "() -> (EventQueueRef _rv)"}, + PyDoc_STR("() -> (EventQueueRef _rv)")}, {"GetCurrentEventTime", (PyCFunction)CarbonEvents_GetCurrentEventTime, 1, - "() -> (double _rv)"}, + PyDoc_STR("() -> (double _rv)")}, {"TrackMouseLocation", (PyCFunction)CarbonEvents_TrackMouseLocation, 1, - "(GrafPtr inPort) -> (Point outPt, UInt16 outResult)"}, + PyDoc_STR("(GrafPtr inPort) -> (Point outPt, UInt16 outResult)")}, {"TrackMouseLocationWithOptions", (PyCFunction)CarbonEvents_TrackMouseLocationWithOptions, 1, - "(GrafPtr inPort, OptionBits inOptions, double inTimeout) -> (Point outPt, UInt32 outModifiers, UInt16 outResult)"}, + PyDoc_STR("(GrafPtr inPort, OptionBits inOptions, double inTimeout) -> (Point outPt, UInt32 outModifiers, UInt16 outResult)")}, {"TrackMouseRegion", (PyCFunction)CarbonEvents_TrackMouseRegion, 1, - "(GrafPtr inPort, RgnHandle inRegion, Boolean ioWasInRgn) -> (Boolean ioWasInRgn, UInt16 outResult)"}, + PyDoc_STR("(GrafPtr inPort, RgnHandle inRegion, Boolean ioWasInRgn) -> (Boolean ioWasInRgn, UInt16 outResult)")}, {"GetLastUserEventTime", (PyCFunction)CarbonEvents_GetLastUserEventTime, 1, - "() -> (double _rv)"}, + PyDoc_STR("() -> (double _rv)")}, {"GetWindowEventTarget", (PyCFunction)CarbonEvents_GetWindowEventTarget, 1, - "(WindowPtr inWindow) -> (EventTargetRef _rv)"}, + PyDoc_STR("(WindowPtr inWindow) -> (EventTargetRef _rv)")}, {"GetControlEventTarget", (PyCFunction)CarbonEvents_GetControlEventTarget, 1, - "(ControlHandle inControl) -> (EventTargetRef _rv)"}, + PyDoc_STR("(ControlHandle inControl) -> (EventTargetRef _rv)")}, {"GetMenuEventTarget", (PyCFunction)CarbonEvents_GetMenuEventTarget, 1, - "(MenuHandle inMenu) -> (EventTargetRef _rv)"}, + PyDoc_STR("(MenuHandle inMenu) -> (EventTargetRef _rv)")}, {"GetApplicationEventTarget", (PyCFunction)CarbonEvents_GetApplicationEventTarget, 1, - "() -> (EventTargetRef _rv)"}, + PyDoc_STR("() -> (EventTargetRef _rv)")}, {"GetUserFocusEventTarget", (PyCFunction)CarbonEvents_GetUserFocusEventTarget, 1, - "() -> (EventTargetRef _rv)"}, + PyDoc_STR("() -> (EventTargetRef _rv)")}, {"GetEventDispatcherTarget", (PyCFunction)CarbonEvents_GetEventDispatcherTarget, 1, - "() -> (EventTargetRef _rv)"}, + PyDoc_STR("() -> (EventTargetRef _rv)")}, {"QuitApplicationEventLoop", (PyCFunction)CarbonEvents_QuitApplicationEventLoop, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"RunAppModalLoopForWindow", (PyCFunction)CarbonEvents_RunAppModalLoopForWindow, 1, - "(WindowPtr inWindow) -> None"}, + PyDoc_STR("(WindowPtr inWindow) -> None")}, {"QuitAppModalLoopForWindow", (PyCFunction)CarbonEvents_QuitAppModalLoopForWindow, 1, - "(WindowPtr inWindow) -> None"}, + PyDoc_STR("(WindowPtr inWindow) -> None")}, {"BeginAppModalStateForWindow", (PyCFunction)CarbonEvents_BeginAppModalStateForWindow, 1, - "(WindowPtr inWindow) -> None"}, + PyDoc_STR("(WindowPtr inWindow) -> None")}, {"EndAppModalStateForWindow", (PyCFunction)CarbonEvents_EndAppModalStateForWindow, 1, - "(WindowPtr inWindow) -> None"}, + PyDoc_STR("(WindowPtr inWindow) -> None")}, {"SetUserFocusWindow", (PyCFunction)CarbonEvents_SetUserFocusWindow, 1, - "(WindowPtr inWindow) -> None"}, + PyDoc_STR("(WindowPtr inWindow) -> None")}, {"GetUserFocusWindow", (PyCFunction)CarbonEvents_GetUserFocusWindow, 1, - "() -> (WindowPtr _rv)"}, + PyDoc_STR("() -> (WindowPtr _rv)")}, {"SetWindowDefaultButton", (PyCFunction)CarbonEvents_SetWindowDefaultButton, 1, - "(WindowPtr inWindow, ControlHandle inControl) -> None"}, + PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl) -> None")}, {"SetWindowCancelButton", (PyCFunction)CarbonEvents_SetWindowCancelButton, 1, - "(WindowPtr inWindow, ControlHandle inControl) -> None"}, + PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl) -> None")}, {"GetWindowDefaultButton", (PyCFunction)CarbonEvents_GetWindowDefaultButton, 1, - "(WindowPtr inWindow) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")}, {"GetWindowCancelButton", (PyCFunction)CarbonEvents_GetWindowCancelButton, 1, - "(WindowPtr inWindow) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")}, {"RegisterEventHotKey", (PyCFunction)CarbonEvents_RegisterEventHotKey, 1, - "(UInt32 inHotKeyCode, UInt32 inHotKeyModifiers, EventHotKeyID inHotKeyID, EventTargetRef inTarget, OptionBits inOptions) -> (EventHotKeyRef outRef)"}, + PyDoc_STR("(UInt32 inHotKeyCode, UInt32 inHotKeyModifiers, EventHotKeyID inHotKeyID, EventTargetRef inTarget, OptionBits inOptions) -> (EventHotKeyRef outRef)")}, {"RunApplicationEventLoop", (PyCFunction)CarbonEvents_RunApplicationEventLoop, 1, - "() -> ()"}, + PyDoc_STR("() -> ()")}, {NULL, NULL, 0} }; diff --git a/Mac/Modules/cf/_CFmodule.c b/Mac/Modules/cf/_CFmodule.c index eb3f3f6..2942082 100644 --- a/Mac/Modules/cf/_CFmodule.c +++ b/Mac/Modules/cf/_CFmodule.c @@ -360,29 +360,29 @@ static PyObject *CFTypeRefObj_toPython(CFTypeRefObject *_self, PyObject *_args) static PyMethodDef CFTypeRefObj_methods[] = { {"CFGetTypeID", (PyCFunction)CFTypeRefObj_CFGetTypeID, 1, - "() -> (CFTypeID _rv)"}, + PyDoc_STR("() -> (CFTypeID _rv)")}, {"CFRetain", (PyCFunction)CFTypeRefObj_CFRetain, 1, - "() -> (CFTypeRef _rv)"}, + PyDoc_STR("() -> (CFTypeRef _rv)")}, {"CFRelease", (PyCFunction)CFTypeRefObj_CFRelease, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CFGetRetainCount", (PyCFunction)CFTypeRefObj_CFGetRetainCount, 1, - "() -> (CFIndex _rv)"}, + PyDoc_STR("() -> (CFIndex _rv)")}, {"CFEqual", (PyCFunction)CFTypeRefObj_CFEqual, 1, - "(CFTypeRef cf2) -> (Boolean _rv)"}, + PyDoc_STR("(CFTypeRef cf2) -> (Boolean _rv)")}, {"CFHash", (PyCFunction)CFTypeRefObj_CFHash, 1, - "() -> (CFHashCode _rv)"}, + PyDoc_STR("() -> (CFHashCode _rv)")}, {"CFCopyDescription", (PyCFunction)CFTypeRefObj_CFCopyDescription, 1, - "() -> (CFStringRef _rv)"}, + PyDoc_STR("() -> (CFStringRef _rv)")}, {"CFPropertyListCreateXMLData", (PyCFunction)CFTypeRefObj_CFPropertyListCreateXMLData, 1, - "() -> (CFDataRef _rv)"}, + PyDoc_STR("() -> (CFDataRef _rv)")}, {"CFPropertyListCreateDeepCopy", (PyCFunction)CFTypeRefObj_CFPropertyListCreateDeepCopy, 1, - "(CFOptionFlags mutabilityOption) -> (CFTypeRef _rv)"}, + PyDoc_STR("(CFOptionFlags mutabilityOption) -> (CFTypeRef _rv)")}, {"CFShow", (PyCFunction)CFTypeRefObj_CFShow, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CFPropertyListCreateFromXMLData", (PyCFunction)CFTypeRefObj_CFPropertyListCreateFromXMLData, 1, - "(CFOptionFlags mutabilityOption) -> (CFTypeRefObj)"}, + PyDoc_STR("(CFOptionFlags mutabilityOption) -> (CFTypeRefObj)")}, {"toPython", (PyCFunction)CFTypeRefObj_toPython, 1, - "() -> (python_object)"}, + PyDoc_STR("() -> (python_object)")}, {NULL, NULL, 0} }; @@ -534,11 +534,11 @@ static PyObject *CFArrayRefObj_CFStringCreateByCombiningStrings(CFArrayRefObject static PyMethodDef CFArrayRefObj_methods[] = { {"CFArrayCreateCopy", (PyCFunction)CFArrayRefObj_CFArrayCreateCopy, 1, - "() -> (CFArrayRef _rv)"}, + PyDoc_STR("() -> (CFArrayRef _rv)")}, {"CFArrayGetCount", (PyCFunction)CFArrayRefObj_CFArrayGetCount, 1, - "() -> (CFIndex _rv)"}, + PyDoc_STR("() -> (CFIndex _rv)")}, {"CFStringCreateByCombiningStrings", (PyCFunction)CFArrayRefObj_CFStringCreateByCombiningStrings, 1, - "(CFStringRef separatorString) -> (CFStringRef _rv)"}, + PyDoc_STR("(CFStringRef separatorString) -> (CFStringRef _rv)")}, {NULL, NULL, 0} }; @@ -717,13 +717,13 @@ static PyObject *CFMutableArrayRefObj_CFArrayAppendArray(CFMutableArrayRefObject static PyMethodDef CFMutableArrayRefObj_methods[] = { {"CFArrayRemoveValueAtIndex", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveValueAtIndex, 1, - "(CFIndex idx) -> None"}, + PyDoc_STR("(CFIndex idx) -> None")}, {"CFArrayRemoveAllValues", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveAllValues, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CFArrayExchangeValuesAtIndices", (PyCFunction)CFMutableArrayRefObj_CFArrayExchangeValuesAtIndices, 1, - "(CFIndex idx1, CFIndex idx2) -> None"}, + PyDoc_STR("(CFIndex idx1, CFIndex idx2) -> None")}, {"CFArrayAppendArray", (PyCFunction)CFMutableArrayRefObj_CFArrayAppendArray, 1, - "(CFArrayRef otherArray, CFRange otherRange) -> None"}, + PyDoc_STR("(CFArrayRef otherArray, CFRange otherRange) -> None")}, {NULL, NULL, 0} }; @@ -859,9 +859,9 @@ static PyObject *CFDictionaryRefObj_CFDictionaryGetCount(CFDictionaryRefObject * static PyMethodDef CFDictionaryRefObj_methods[] = { {"CFDictionaryCreateCopy", (PyCFunction)CFDictionaryRefObj_CFDictionaryCreateCopy, 1, - "() -> (CFDictionaryRef _rv)"}, + PyDoc_STR("() -> (CFDictionaryRef _rv)")}, {"CFDictionaryGetCount", (PyCFunction)CFDictionaryRefObj_CFDictionaryGetCount, 1, - "() -> (CFIndex _rv)"}, + PyDoc_STR("() -> (CFIndex _rv)")}, {NULL, NULL, 0} }; @@ -983,7 +983,7 @@ static PyObject *CFMutableDictionaryRefObj_CFDictionaryRemoveAllValues(CFMutable static PyMethodDef CFMutableDictionaryRefObj_methods[] = { {"CFDictionaryRemoveAllValues", (PyCFunction)CFMutableDictionaryRefObj_CFDictionaryRemoveAllValues, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {NULL, NULL, 0} }; @@ -1153,13 +1153,13 @@ static PyObject *CFDataRefObj_CFDataGetData(CFDataRefObject *_self, PyObject *_a static PyMethodDef CFDataRefObj_methods[] = { {"CFDataCreateCopy", (PyCFunction)CFDataRefObj_CFDataCreateCopy, 1, - "() -> (CFDataRef _rv)"}, + PyDoc_STR("() -> (CFDataRef _rv)")}, {"CFDataGetLength", (PyCFunction)CFDataRefObj_CFDataGetLength, 1, - "() -> (CFIndex _rv)"}, + PyDoc_STR("() -> (CFIndex _rv)")}, {"CFStringCreateFromExternalRepresentation", (PyCFunction)CFDataRefObj_CFStringCreateFromExternalRepresentation, 1, - "(CFStringEncoding encoding) -> (CFStringRef _rv)"}, + PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")}, {"CFDataGetData", (PyCFunction)CFDataRefObj_CFDataGetData, 1, - "() -> (string _rv)"}, + PyDoc_STR("() -> (string _rv)")}, {NULL, NULL, 0} }; @@ -1361,15 +1361,15 @@ static PyObject *CFMutableDataRefObj_CFDataDeleteBytes(CFMutableDataRefObject *_ static PyMethodDef CFMutableDataRefObj_methods[] = { {"CFDataSetLength", (PyCFunction)CFMutableDataRefObj_CFDataSetLength, 1, - "(CFIndex length) -> None"}, + PyDoc_STR("(CFIndex length) -> None")}, {"CFDataIncreaseLength", (PyCFunction)CFMutableDataRefObj_CFDataIncreaseLength, 1, - "(CFIndex extraLength) -> None"}, + PyDoc_STR("(CFIndex extraLength) -> None")}, {"CFDataAppendBytes", (PyCFunction)CFMutableDataRefObj_CFDataAppendBytes, 1, - "(Buffer bytes) -> None"}, + PyDoc_STR("(Buffer bytes) -> None")}, {"CFDataReplaceBytes", (PyCFunction)CFMutableDataRefObj_CFDataReplaceBytes, 1, - "(CFRange range, Buffer newBytes) -> None"}, + PyDoc_STR("(CFRange range, Buffer newBytes) -> None")}, {"CFDataDeleteBytes", (PyCFunction)CFMutableDataRefObj_CFDataDeleteBytes, 1, - "(CFRange range) -> None"}, + PyDoc_STR("(CFRange range) -> None")}, {NULL, NULL, 0} }; @@ -2002,59 +2002,59 @@ static PyObject *CFStringRefObj_CFStringGetUnicode(CFStringRefObject *_self, PyO static PyMethodDef CFStringRefObj_methods[] = { {"CFStringCreateWithSubstring", (PyCFunction)CFStringRefObj_CFStringCreateWithSubstring, 1, - "(CFRange range) -> (CFStringRef _rv)"}, + PyDoc_STR("(CFRange range) -> (CFStringRef _rv)")}, {"CFStringCreateCopy", (PyCFunction)CFStringRefObj_CFStringCreateCopy, 1, - "() -> (CFStringRef _rv)"}, + PyDoc_STR("() -> (CFStringRef _rv)")}, {"CFStringGetLength", (PyCFunction)CFStringRefObj_CFStringGetLength, 1, - "() -> (CFIndex _rv)"}, + PyDoc_STR("() -> (CFIndex _rv)")}, {"CFStringGetBytes", (PyCFunction)CFStringRefObj_CFStringGetBytes, 1, - "(CFRange range, CFStringEncoding encoding, UInt8 lossByte, Boolean isExternalRepresentation, CFIndex maxBufLen) -> (CFIndex _rv, UInt8 buffer, CFIndex usedBufLen)"}, + PyDoc_STR("(CFRange range, CFStringEncoding encoding, UInt8 lossByte, Boolean isExternalRepresentation, CFIndex maxBufLen) -> (CFIndex _rv, UInt8 buffer, CFIndex usedBufLen)")}, {"CFStringCreateExternalRepresentation", (PyCFunction)CFStringRefObj_CFStringCreateExternalRepresentation, 1, - "(CFStringEncoding encoding, UInt8 lossByte) -> (CFDataRef _rv)"}, + PyDoc_STR("(CFStringEncoding encoding, UInt8 lossByte) -> (CFDataRef _rv)")}, {"CFStringGetSmallestEncoding", (PyCFunction)CFStringRefObj_CFStringGetSmallestEncoding, 1, - "() -> (CFStringEncoding _rv)"}, + PyDoc_STR("() -> (CFStringEncoding _rv)")}, {"CFStringGetFastestEncoding", (PyCFunction)CFStringRefObj_CFStringGetFastestEncoding, 1, - "() -> (CFStringEncoding _rv)"}, + PyDoc_STR("() -> (CFStringEncoding _rv)")}, {"CFStringCompareWithOptions", (PyCFunction)CFStringRefObj_CFStringCompareWithOptions, 1, - "(CFStringRef theString2, CFRange rangeToCompare, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)"}, + PyDoc_STR("(CFStringRef theString2, CFRange rangeToCompare, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)")}, {"CFStringCompare", (PyCFunction)CFStringRefObj_CFStringCompare, 1, - "(CFStringRef theString2, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)"}, + PyDoc_STR("(CFStringRef theString2, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)")}, {"CFStringFindWithOptions", (PyCFunction)CFStringRefObj_CFStringFindWithOptions, 1, - "(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags searchOptions) -> (Boolean _rv, CFRange result)"}, + PyDoc_STR("(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags searchOptions) -> (Boolean _rv, CFRange result)")}, {"CFStringCreateArrayWithFindResults", (PyCFunction)CFStringRefObj_CFStringCreateArrayWithFindResults, 1, - "(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags compareOptions) -> (CFArrayRef _rv)"}, + PyDoc_STR("(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags compareOptions) -> (CFArrayRef _rv)")}, {"CFStringFind", (PyCFunction)CFStringRefObj_CFStringFind, 1, - "(CFStringRef stringToFind, CFOptionFlags compareOptions) -> (CFRange _rv)"}, + PyDoc_STR("(CFStringRef stringToFind, CFOptionFlags compareOptions) -> (CFRange _rv)")}, {"CFStringHasPrefix", (PyCFunction)CFStringRefObj_CFStringHasPrefix, 1, - "(CFStringRef prefix) -> (Boolean _rv)"}, + PyDoc_STR("(CFStringRef prefix) -> (Boolean _rv)")}, {"CFStringHasSuffix", (PyCFunction)CFStringRefObj_CFStringHasSuffix, 1, - "(CFStringRef suffix) -> (Boolean _rv)"}, + PyDoc_STR("(CFStringRef suffix) -> (Boolean _rv)")}, {"CFStringGetLineBounds", (PyCFunction)CFStringRefObj_CFStringGetLineBounds, 1, - "(CFRange range) -> (CFIndex lineBeginIndex, CFIndex lineEndIndex, CFIndex contentsEndIndex)"}, + PyDoc_STR("(CFRange range) -> (CFIndex lineBeginIndex, CFIndex lineEndIndex, CFIndex contentsEndIndex)")}, {"CFStringCreateArrayBySeparatingStrings", (PyCFunction)CFStringRefObj_CFStringCreateArrayBySeparatingStrings, 1, - "(CFStringRef separatorString) -> (CFArrayRef _rv)"}, + PyDoc_STR("(CFStringRef separatorString) -> (CFArrayRef _rv)")}, {"CFStringGetIntValue", (PyCFunction)CFStringRefObj_CFStringGetIntValue, 1, - "() -> (SInt32 _rv)"}, + PyDoc_STR("() -> (SInt32 _rv)")}, {"CFStringGetDoubleValue", (PyCFunction)CFStringRefObj_CFStringGetDoubleValue, 1, - "() -> (double _rv)"}, + PyDoc_STR("() -> (double _rv)")}, {"CFStringConvertIANACharSetNameToEncoding", (PyCFunction)CFStringRefObj_CFStringConvertIANACharSetNameToEncoding, 1, - "() -> (CFStringEncoding _rv)"}, + PyDoc_STR("() -> (CFStringEncoding _rv)")}, {"CFShowStr", (PyCFunction)CFStringRefObj_CFShowStr, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CFURLCreateWithString", (PyCFunction)CFStringRefObj_CFURLCreateWithString, 1, - "(CFURLRef baseURL) -> (CFURLRef _rv)"}, + PyDoc_STR("(CFURLRef baseURL) -> (CFURLRef _rv)")}, {"CFURLCreateWithFileSystemPath", (PyCFunction)CFStringRefObj_CFURLCreateWithFileSystemPath, 1, - "(CFURLPathStyle pathStyle, Boolean isDirectory) -> (CFURLRef _rv)"}, + PyDoc_STR("(CFURLPathStyle pathStyle, Boolean isDirectory) -> (CFURLRef _rv)")}, {"CFURLCreateWithFileSystemPathRelativeToBase", (PyCFunction)CFStringRefObj_CFURLCreateWithFileSystemPathRelativeToBase, 1, - "(CFURLPathStyle pathStyle, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)"}, + PyDoc_STR("(CFURLPathStyle pathStyle, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)")}, {"CFURLCreateStringByReplacingPercentEscapes", (PyCFunction)CFStringRefObj_CFURLCreateStringByReplacingPercentEscapes, 1, - "(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"}, + PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")}, {"CFURLCreateStringByAddingPercentEscapes", (PyCFunction)CFStringRefObj_CFURLCreateStringByAddingPercentEscapes, 1, - "(CFStringRef charactersToLeaveUnescaped, CFStringRef legalURLCharactersToBeEscaped, CFStringEncoding encoding) -> (CFStringRef _rv)"}, + PyDoc_STR("(CFStringRef charactersToLeaveUnescaped, CFStringRef legalURLCharactersToBeEscaped, CFStringEncoding encoding) -> (CFStringRef _rv)")}, {"CFStringGetString", (PyCFunction)CFStringRefObj_CFStringGetString, 1, - "() -> (string _rv)"}, + PyDoc_STR("() -> (string _rv)")}, {"CFStringGetUnicode", (PyCFunction)CFStringRefObj_CFStringGetUnicode, 1, - "() -> (unicode _rv)"}, + PyDoc_STR("() -> (unicode _rv)")}, {NULL, NULL, 0} }; @@ -2367,27 +2367,27 @@ static PyObject *CFMutableStringRefObj_CFStringTrimWhitespace(CFMutableStringRef static PyMethodDef CFMutableStringRefObj_methods[] = { {"CFStringAppend", (PyCFunction)CFMutableStringRefObj_CFStringAppend, 1, - "(CFStringRef appendedString) -> None"}, + PyDoc_STR("(CFStringRef appendedString) -> None")}, {"CFStringAppendCharacters", (PyCFunction)CFMutableStringRefObj_CFStringAppendCharacters, 1, - "(Buffer chars) -> None"}, + PyDoc_STR("(Buffer chars) -> None")}, {"CFStringAppendPascalString", (PyCFunction)CFMutableStringRefObj_CFStringAppendPascalString, 1, - "(Str255 pStr, CFStringEncoding encoding) -> None"}, + PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> None")}, {"CFStringAppendCString", (PyCFunction)CFMutableStringRefObj_CFStringAppendCString, 1, - "(char* cStr, CFStringEncoding encoding) -> None"}, + PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> None")}, {"CFStringInsert", (PyCFunction)CFMutableStringRefObj_CFStringInsert, 1, - "(CFIndex idx, CFStringRef insertedStr) -> None"}, + PyDoc_STR("(CFIndex idx, CFStringRef insertedStr) -> None")}, {"CFStringDelete", (PyCFunction)CFMutableStringRefObj_CFStringDelete, 1, - "(CFRange range) -> None"}, + PyDoc_STR("(CFRange range) -> None")}, {"CFStringReplace", (PyCFunction)CFMutableStringRefObj_CFStringReplace, 1, - "(CFRange range, CFStringRef replacement) -> None"}, + PyDoc_STR("(CFRange range, CFStringRef replacement) -> None")}, {"CFStringReplaceAll", (PyCFunction)CFMutableStringRefObj_CFStringReplaceAll, 1, - "(CFStringRef replacement) -> None"}, + PyDoc_STR("(CFStringRef replacement) -> None")}, {"CFStringPad", (PyCFunction)CFMutableStringRefObj_CFStringPad, 1, - "(CFStringRef padString, CFIndex length, CFIndex indexIntoPad) -> None"}, + PyDoc_STR("(CFStringRef padString, CFIndex length, CFIndex indexIntoPad) -> None")}, {"CFStringTrim", (PyCFunction)CFMutableStringRefObj_CFStringTrim, 1, - "(CFStringRef trimString) -> None"}, + PyDoc_STR("(CFStringRef trimString) -> None")}, {"CFStringTrimWhitespace", (PyCFunction)CFMutableStringRefObj_CFStringTrimWhitespace, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {NULL, NULL, 0} }; @@ -2932,59 +2932,59 @@ static PyObject *CFURLRefObj_CFURLGetFSRef(CFURLRefObject *_self, PyObject *_arg static PyMethodDef CFURLRefObj_methods[] = { {"CFURLCreateData", (PyCFunction)CFURLRefObj_CFURLCreateData, 1, - "(CFStringEncoding encoding, Boolean escapeWhitespace) -> (CFDataRef _rv)"}, + PyDoc_STR("(CFStringEncoding encoding, Boolean escapeWhitespace) -> (CFDataRef _rv)")}, {"CFURLGetFileSystemRepresentation", (PyCFunction)CFURLRefObj_CFURLGetFileSystemRepresentation, 1, - "(Boolean resolveAgainstBase, CFIndex maxBufLen) -> (Boolean _rv, UInt8 buffer)"}, + PyDoc_STR("(Boolean resolveAgainstBase, CFIndex maxBufLen) -> (Boolean _rv, UInt8 buffer)")}, {"CFURLCopyAbsoluteURL", (PyCFunction)CFURLRefObj_CFURLCopyAbsoluteURL, 1, - "() -> (CFURLRef _rv)"}, + PyDoc_STR("() -> (CFURLRef _rv)")}, {"CFURLGetString", (PyCFunction)CFURLRefObj_CFURLGetString, 1, - "() -> (CFStringRef _rv)"}, + PyDoc_STR("() -> (CFStringRef _rv)")}, {"CFURLGetBaseURL", (PyCFunction)CFURLRefObj_CFURLGetBaseURL, 1, - "() -> (CFURLRef _rv)"}, + PyDoc_STR("() -> (CFURLRef _rv)")}, {"CFURLCanBeDecomposed", (PyCFunction)CFURLRefObj_CFURLCanBeDecomposed, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, {"CFURLCopyScheme", (PyCFunction)CFURLRefObj_CFURLCopyScheme, 1, - "() -> (CFStringRef _rv)"}, + PyDoc_STR("() -> (CFStringRef _rv)")}, {"CFURLCopyNetLocation", (PyCFunction)CFURLRefObj_CFURLCopyNetLocation, 1, - "() -> (CFStringRef _rv)"}, + PyDoc_STR("() -> (CFStringRef _rv)")}, {"CFURLCopyPath", (PyCFunction)CFURLRefObj_CFURLCopyPath, 1, - "() -> (CFStringRef _rv)"}, + PyDoc_STR("() -> (CFStringRef _rv)")}, {"CFURLCopyStrictPath", (PyCFunction)CFURLRefObj_CFURLCopyStrictPath, 1, - "() -> (CFStringRef _rv, Boolean isAbsolute)"}, + PyDoc_STR("() -> (CFStringRef _rv, Boolean isAbsolute)")}, {"CFURLCopyFileSystemPath", (PyCFunction)CFURLRefObj_CFURLCopyFileSystemPath, 1, - "(CFURLPathStyle pathStyle) -> (CFStringRef _rv)"}, + PyDoc_STR("(CFURLPathStyle pathStyle) -> (CFStringRef _rv)")}, {"CFURLHasDirectoryPath", (PyCFunction)CFURLRefObj_CFURLHasDirectoryPath, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, {"CFURLCopyResourceSpecifier", (PyCFunction)CFURLRefObj_CFURLCopyResourceSpecifier, 1, - "() -> (CFStringRef _rv)"}, + PyDoc_STR("() -> (CFStringRef _rv)")}, {"CFURLCopyHostName", (PyCFunction)CFURLRefObj_CFURLCopyHostName, 1, - "() -> (CFStringRef _rv)"}, + PyDoc_STR("() -> (CFStringRef _rv)")}, {"CFURLGetPortNumber", (PyCFunction)CFURLRefObj_CFURLGetPortNumber, 1, - "() -> (SInt32 _rv)"}, + PyDoc_STR("() -> (SInt32 _rv)")}, {"CFURLCopyUserName", (PyCFunction)CFURLRefObj_CFURLCopyUserName, 1, - "() -> (CFStringRef _rv)"}, + PyDoc_STR("() -> (CFStringRef _rv)")}, {"CFURLCopyPassword", (PyCFunction)CFURLRefObj_CFURLCopyPassword, 1, - "() -> (CFStringRef _rv)"}, + PyDoc_STR("() -> (CFStringRef _rv)")}, {"CFURLCopyParameterString", (PyCFunction)CFURLRefObj_CFURLCopyParameterString, 1, - "(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"}, + PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")}, {"CFURLCopyQueryString", (PyCFunction)CFURLRefObj_CFURLCopyQueryString, 1, - "(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"}, + PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")}, {"CFURLCopyFragment", (PyCFunction)CFURLRefObj_CFURLCopyFragment, 1, - "(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"}, + PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")}, {"CFURLCopyLastPathComponent", (PyCFunction)CFURLRefObj_CFURLCopyLastPathComponent, 1, - "() -> (CFStringRef _rv)"}, + PyDoc_STR("() -> (CFStringRef _rv)")}, {"CFURLCopyPathExtension", (PyCFunction)CFURLRefObj_CFURLCopyPathExtension, 1, - "() -> (CFStringRef _rv)"}, + PyDoc_STR("() -> (CFStringRef _rv)")}, {"CFURLCreateCopyAppendingPathComponent", (PyCFunction)CFURLRefObj_CFURLCreateCopyAppendingPathComponent, 1, - "(CFStringRef pathComponent, Boolean isDirectory) -> (CFURLRef _rv)"}, + PyDoc_STR("(CFStringRef pathComponent, Boolean isDirectory) -> (CFURLRef _rv)")}, {"CFURLCreateCopyDeletingLastPathComponent", (PyCFunction)CFURLRefObj_CFURLCreateCopyDeletingLastPathComponent, 1, - "() -> (CFURLRef _rv)"}, + PyDoc_STR("() -> (CFURLRef _rv)")}, {"CFURLCreateCopyAppendingPathExtension", (PyCFunction)CFURLRefObj_CFURLCreateCopyAppendingPathExtension, 1, - "(CFStringRef extension) -> (CFURLRef _rv)"}, + PyDoc_STR("(CFStringRef extension) -> (CFURLRef _rv)")}, {"CFURLCreateCopyDeletingPathExtension", (PyCFunction)CFURLRefObj_CFURLCreateCopyDeletingPathExtension, 1, - "() -> (CFURLRef _rv)"}, + PyDoc_STR("() -> (CFURLRef _rv)")}, {"CFURLGetFSRef", (PyCFunction)CFURLRefObj_CFURLGetFSRef, 1, - "() -> (Boolean _rv, FSRef fsRef)"}, + PyDoc_STR("() -> (Boolean _rv, FSRef fsRef)")}, {NULL, NULL, 0} }; @@ -4173,117 +4173,117 @@ static PyObject *CF_toCF(PyObject *_self, PyObject *_args) static PyMethodDef CF_methods[] = { {"__CFRangeMake", (PyCFunction)CF___CFRangeMake, 1, - "(CFIndex loc, CFIndex len) -> (CFRange _rv)"}, + PyDoc_STR("(CFIndex loc, CFIndex len) -> (CFRange _rv)")}, {"CFAllocatorGetTypeID", (PyCFunction)CF_CFAllocatorGetTypeID, 1, - "() -> (CFTypeID _rv)"}, + PyDoc_STR("() -> (CFTypeID _rv)")}, {"CFAllocatorGetPreferredSizeForSize", (PyCFunction)CF_CFAllocatorGetPreferredSizeForSize, 1, - "(CFIndex size, CFOptionFlags hint) -> (CFIndex _rv)"}, + PyDoc_STR("(CFIndex size, CFOptionFlags hint) -> (CFIndex _rv)")}, {"CFCopyTypeIDDescription", (PyCFunction)CF_CFCopyTypeIDDescription, 1, - "(CFTypeID type_id) -> (CFStringRef _rv)"}, + PyDoc_STR("(CFTypeID type_id) -> (CFStringRef _rv)")}, {"CFArrayGetTypeID", (PyCFunction)CF_CFArrayGetTypeID, 1, - "() -> (CFTypeID _rv)"}, + PyDoc_STR("() -> (CFTypeID _rv)")}, {"CFArrayCreateMutable", (PyCFunction)CF_CFArrayCreateMutable, 1, - "(CFIndex capacity) -> (CFMutableArrayRef _rv)"}, + PyDoc_STR("(CFIndex capacity) -> (CFMutableArrayRef _rv)")}, {"CFArrayCreateMutableCopy", (PyCFunction)CF_CFArrayCreateMutableCopy, 1, - "(CFIndex capacity, CFArrayRef theArray) -> (CFMutableArrayRef _rv)"}, + PyDoc_STR("(CFIndex capacity, CFArrayRef theArray) -> (CFMutableArrayRef _rv)")}, {"CFDataGetTypeID", (PyCFunction)CF_CFDataGetTypeID, 1, - "() -> (CFTypeID _rv)"}, + PyDoc_STR("() -> (CFTypeID _rv)")}, {"CFDataCreate", (PyCFunction)CF_CFDataCreate, 1, - "(Buffer bytes) -> (CFDataRef _rv)"}, + PyDoc_STR("(Buffer bytes) -> (CFDataRef _rv)")}, {"CFDataCreateWithBytesNoCopy", (PyCFunction)CF_CFDataCreateWithBytesNoCopy, 1, - "(Buffer bytes) -> (CFDataRef _rv)"}, + PyDoc_STR("(Buffer bytes) -> (CFDataRef _rv)")}, {"CFDataCreateMutable", (PyCFunction)CF_CFDataCreateMutable, 1, - "(CFIndex capacity) -> (CFMutableDataRef _rv)"}, + PyDoc_STR("(CFIndex capacity) -> (CFMutableDataRef _rv)")}, {"CFDataCreateMutableCopy", (PyCFunction)CF_CFDataCreateMutableCopy, 1, - "(CFIndex capacity, CFDataRef theData) -> (CFMutableDataRef _rv)"}, + PyDoc_STR("(CFIndex capacity, CFDataRef theData) -> (CFMutableDataRef _rv)")}, {"CFDictionaryGetTypeID", (PyCFunction)CF_CFDictionaryGetTypeID, 1, - "() -> (CFTypeID _rv)"}, + PyDoc_STR("() -> (CFTypeID _rv)")}, {"CFDictionaryCreateMutable", (PyCFunction)CF_CFDictionaryCreateMutable, 1, - "(CFIndex capacity) -> (CFMutableDictionaryRef _rv)"}, + PyDoc_STR("(CFIndex capacity) -> (CFMutableDictionaryRef _rv)")}, {"CFDictionaryCreateMutableCopy", (PyCFunction)CF_CFDictionaryCreateMutableCopy, 1, - "(CFIndex capacity, CFDictionaryRef theDict) -> (CFMutableDictionaryRef _rv)"}, + PyDoc_STR("(CFIndex capacity, CFDictionaryRef theDict) -> (CFMutableDictionaryRef _rv)")}, {"CFPreferencesCopyAppValue", (PyCFunction)CF_CFPreferencesCopyAppValue, 1, - "(CFStringRef key, CFStringRef applicationID) -> (CFTypeRef _rv)"}, + PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (CFTypeRef _rv)")}, {"CFPreferencesGetAppBooleanValue", (PyCFunction)CF_CFPreferencesGetAppBooleanValue, 1, - "(CFStringRef key, CFStringRef applicationID) -> (Boolean _rv, Boolean keyExistsAndHasValidFormat)"}, + PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (Boolean _rv, Boolean keyExistsAndHasValidFormat)")}, {"CFPreferencesGetAppIntegerValue", (PyCFunction)CF_CFPreferencesGetAppIntegerValue, 1, - "(CFStringRef key, CFStringRef applicationID) -> (CFIndex _rv, Boolean keyExistsAndHasValidFormat)"}, + PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (CFIndex _rv, Boolean keyExistsAndHasValidFormat)")}, {"CFPreferencesSetAppValue", (PyCFunction)CF_CFPreferencesSetAppValue, 1, - "(CFStringRef key, CFTypeRef value, CFStringRef applicationID) -> None"}, + PyDoc_STR("(CFStringRef key, CFTypeRef value, CFStringRef applicationID) -> None")}, {"CFPreferencesAddSuitePreferencesToApp", (PyCFunction)CF_CFPreferencesAddSuitePreferencesToApp, 1, - "(CFStringRef applicationID, CFStringRef suiteID) -> None"}, + PyDoc_STR("(CFStringRef applicationID, CFStringRef suiteID) -> None")}, {"CFPreferencesRemoveSuitePreferencesFromApp", (PyCFunction)CF_CFPreferencesRemoveSuitePreferencesFromApp, 1, - "(CFStringRef applicationID, CFStringRef suiteID) -> None"}, + PyDoc_STR("(CFStringRef applicationID, CFStringRef suiteID) -> None")}, {"CFPreferencesAppSynchronize", (PyCFunction)CF_CFPreferencesAppSynchronize, 1, - "(CFStringRef applicationID) -> (Boolean _rv)"}, + PyDoc_STR("(CFStringRef applicationID) -> (Boolean _rv)")}, {"CFPreferencesCopyValue", (PyCFunction)CF_CFPreferencesCopyValue, 1, - "(CFStringRef key, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFTypeRef _rv)"}, + PyDoc_STR("(CFStringRef key, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFTypeRef _rv)")}, {"CFPreferencesCopyMultiple", (PyCFunction)CF_CFPreferencesCopyMultiple, 1, - "(CFArrayRef keysToFetch, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFDictionaryRef _rv)"}, + PyDoc_STR("(CFArrayRef keysToFetch, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFDictionaryRef _rv)")}, {"CFPreferencesSetValue", (PyCFunction)CF_CFPreferencesSetValue, 1, - "(CFStringRef key, CFTypeRef value, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None"}, + PyDoc_STR("(CFStringRef key, CFTypeRef value, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None")}, {"CFPreferencesSetMultiple", (PyCFunction)CF_CFPreferencesSetMultiple, 1, - "(CFDictionaryRef keysToSet, CFArrayRef keysToRemove, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None"}, + PyDoc_STR("(CFDictionaryRef keysToSet, CFArrayRef keysToRemove, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None")}, {"CFPreferencesSynchronize", (PyCFunction)CF_CFPreferencesSynchronize, 1, - "(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (Boolean _rv)"}, + PyDoc_STR("(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (Boolean _rv)")}, {"CFPreferencesCopyApplicationList", (PyCFunction)CF_CFPreferencesCopyApplicationList, 1, - "(CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)"}, + PyDoc_STR("(CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)")}, {"CFPreferencesCopyKeyList", (PyCFunction)CF_CFPreferencesCopyKeyList, 1, - "(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)"}, + PyDoc_STR("(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)")}, {"CFStringGetTypeID", (PyCFunction)CF_CFStringGetTypeID, 1, - "() -> (CFTypeID _rv)"}, + PyDoc_STR("() -> (CFTypeID _rv)")}, {"CFStringCreateWithPascalString", (PyCFunction)CF_CFStringCreateWithPascalString, 1, - "(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)"}, + PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)")}, {"CFStringCreateWithCString", (PyCFunction)CF_CFStringCreateWithCString, 1, - "(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)"}, + PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)")}, {"CFStringCreateWithCharacters", (PyCFunction)CF_CFStringCreateWithCharacters, 1, - "(Buffer chars) -> (CFStringRef _rv)"}, + PyDoc_STR("(Buffer chars) -> (CFStringRef _rv)")}, {"CFStringCreateWithPascalStringNoCopy", (PyCFunction)CF_CFStringCreateWithPascalStringNoCopy, 1, - "(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)"}, + PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)")}, {"CFStringCreateWithCStringNoCopy", (PyCFunction)CF_CFStringCreateWithCStringNoCopy, 1, - "(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)"}, + PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)")}, {"CFStringCreateWithCharactersNoCopy", (PyCFunction)CF_CFStringCreateWithCharactersNoCopy, 1, - "(Buffer chars) -> (CFStringRef _rv)"}, + PyDoc_STR("(Buffer chars) -> (CFStringRef _rv)")}, {"CFStringCreateMutable", (PyCFunction)CF_CFStringCreateMutable, 1, - "(CFIndex maxLength) -> (CFMutableStringRef _rv)"}, + PyDoc_STR("(CFIndex maxLength) -> (CFMutableStringRef _rv)")}, {"CFStringCreateMutableCopy", (PyCFunction)CF_CFStringCreateMutableCopy, 1, - "(CFIndex maxLength, CFStringRef theString) -> (CFMutableStringRef _rv)"}, + PyDoc_STR("(CFIndex maxLength, CFStringRef theString) -> (CFMutableStringRef _rv)")}, {"CFStringCreateWithBytes", (PyCFunction)CF_CFStringCreateWithBytes, 1, - "(Buffer bytes, CFStringEncoding encoding, Boolean isExternalRepresentation) -> (CFStringRef _rv)"}, + PyDoc_STR("(Buffer bytes, CFStringEncoding encoding, Boolean isExternalRepresentation) -> (CFStringRef _rv)")}, {"CFStringGetSystemEncoding", (PyCFunction)CF_CFStringGetSystemEncoding, 1, - "() -> (CFStringEncoding _rv)"}, + PyDoc_STR("() -> (CFStringEncoding _rv)")}, {"CFStringGetMaximumSizeForEncoding", (PyCFunction)CF_CFStringGetMaximumSizeForEncoding, 1, - "(CFIndex length, CFStringEncoding encoding) -> (CFIndex _rv)"}, + PyDoc_STR("(CFIndex length, CFStringEncoding encoding) -> (CFIndex _rv)")}, {"CFStringIsEncodingAvailable", (PyCFunction)CF_CFStringIsEncodingAvailable, 1, - "(CFStringEncoding encoding) -> (Boolean _rv)"}, + PyDoc_STR("(CFStringEncoding encoding) -> (Boolean _rv)")}, {"CFStringGetNameOfEncoding", (PyCFunction)CF_CFStringGetNameOfEncoding, 1, - "(CFStringEncoding encoding) -> (CFStringRef _rv)"}, + PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")}, {"CFStringConvertEncodingToNSStringEncoding", (PyCFunction)CF_CFStringConvertEncodingToNSStringEncoding, 1, - "(CFStringEncoding encoding) -> (UInt32 _rv)"}, + PyDoc_STR("(CFStringEncoding encoding) -> (UInt32 _rv)")}, {"CFStringConvertNSStringEncodingToEncoding", (PyCFunction)CF_CFStringConvertNSStringEncodingToEncoding, 1, - "(UInt32 encoding) -> (CFStringEncoding _rv)"}, + PyDoc_STR("(UInt32 encoding) -> (CFStringEncoding _rv)")}, {"CFStringConvertEncodingToWindowsCodepage", (PyCFunction)CF_CFStringConvertEncodingToWindowsCodepage, 1, - "(CFStringEncoding encoding) -> (UInt32 _rv)"}, + PyDoc_STR("(CFStringEncoding encoding) -> (UInt32 _rv)")}, {"CFStringConvertWindowsCodepageToEncoding", (PyCFunction)CF_CFStringConvertWindowsCodepageToEncoding, 1, - "(UInt32 codepage) -> (CFStringEncoding _rv)"}, + PyDoc_STR("(UInt32 codepage) -> (CFStringEncoding _rv)")}, {"CFStringConvertEncodingToIANACharSetName", (PyCFunction)CF_CFStringConvertEncodingToIANACharSetName, 1, - "(CFStringEncoding encoding) -> (CFStringRef _rv)"}, + PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")}, {"CFStringGetMostCompatibleMacStringEncoding", (PyCFunction)CF_CFStringGetMostCompatibleMacStringEncoding, 1, - "(CFStringEncoding encoding) -> (CFStringEncoding _rv)"}, + PyDoc_STR("(CFStringEncoding encoding) -> (CFStringEncoding _rv)")}, {"__CFStringMakeConstantString", (PyCFunction)CF___CFStringMakeConstantString, 1, - "(char* cStr) -> (CFStringRef _rv)"}, + PyDoc_STR("(char* cStr) -> (CFStringRef _rv)")}, {"CFURLGetTypeID", (PyCFunction)CF_CFURLGetTypeID, 1, - "() -> (CFTypeID _rv)"}, + PyDoc_STR("() -> (CFTypeID _rv)")}, {"CFURLCreateWithBytes", (PyCFunction)CF_CFURLCreateWithBytes, 1, - "(Buffer URLBytes, CFStringEncoding encoding, CFURLRef baseURL) -> (CFURLRef _rv)"}, + PyDoc_STR("(Buffer URLBytes, CFStringEncoding encoding, CFURLRef baseURL) -> (CFURLRef _rv)")}, {"CFURLCreateFromFileSystemRepresentation", (PyCFunction)CF_CFURLCreateFromFileSystemRepresentation, 1, - "(Buffer buffer, Boolean isDirectory) -> (CFURLRef _rv)"}, + PyDoc_STR("(Buffer buffer, Boolean isDirectory) -> (CFURLRef _rv)")}, {"CFURLCreateFromFileSystemRepresentationRelativeToBase", (PyCFunction)CF_CFURLCreateFromFileSystemRepresentationRelativeToBase, 1, - "(Buffer buffer, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)"}, + PyDoc_STR("(Buffer buffer, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)")}, {"CFURLCreateFromFSRef", (PyCFunction)CF_CFURLCreateFromFSRef, 1, - "(FSRef fsRef) -> (CFURLRef _rv)"}, + PyDoc_STR("(FSRef fsRef) -> (CFURLRef _rv)")}, {"toCF", (PyCFunction)CF_toCF, 1, - "(python_object) -> (CF_object)"}, + PyDoc_STR("(python_object) -> (CF_object)")}, {NULL, NULL, 0} }; diff --git a/Mac/Modules/cg/_CGmodule.c b/Mac/Modules/cg/_CGmodule.c index 69bd77c..069889a 100755 --- a/Mac/Modules/cg/_CGmodule.c +++ b/Mac/Modules/cg/_CGmodule.c @@ -1148,121 +1148,121 @@ static PyObject *CGContextRefObj_ClipCGContextToRegion(CGContextRefObject *_self static PyMethodDef CGContextRefObj_methods[] = { {"CGContextSaveGState", (PyCFunction)CGContextRefObj_CGContextSaveGState, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CGContextRestoreGState", (PyCFunction)CGContextRefObj_CGContextRestoreGState, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CGContextScaleCTM", (PyCFunction)CGContextRefObj_CGContextScaleCTM, 1, - "(float sx, float sy) -> None"}, + PyDoc_STR("(float sx, float sy) -> None")}, {"CGContextTranslateCTM", (PyCFunction)CGContextRefObj_CGContextTranslateCTM, 1, - "(float tx, float ty) -> None"}, + PyDoc_STR("(float tx, float ty) -> None")}, {"CGContextRotateCTM", (PyCFunction)CGContextRefObj_CGContextRotateCTM, 1, - "(float angle) -> None"}, + PyDoc_STR("(float angle) -> None")}, {"CGContextConcatCTM", (PyCFunction)CGContextRefObj_CGContextConcatCTM, 1, - "(CGAffineTransform transform) -> None"}, + PyDoc_STR("(CGAffineTransform transform) -> None")}, {"CGContextGetCTM", (PyCFunction)CGContextRefObj_CGContextGetCTM, 1, - "() -> (CGAffineTransform _rv)"}, + PyDoc_STR("() -> (CGAffineTransform _rv)")}, {"CGContextSetLineWidth", (PyCFunction)CGContextRefObj_CGContextSetLineWidth, 1, - "(float width) -> None"}, + PyDoc_STR("(float width) -> None")}, {"CGContextSetLineCap", (PyCFunction)CGContextRefObj_CGContextSetLineCap, 1, - "(int cap) -> None"}, + PyDoc_STR("(int cap) -> None")}, {"CGContextSetLineJoin", (PyCFunction)CGContextRefObj_CGContextSetLineJoin, 1, - "(int join) -> None"}, + PyDoc_STR("(int join) -> None")}, {"CGContextSetMiterLimit", (PyCFunction)CGContextRefObj_CGContextSetMiterLimit, 1, - "(float limit) -> None"}, + PyDoc_STR("(float limit) -> None")}, {"CGContextSetFlatness", (PyCFunction)CGContextRefObj_CGContextSetFlatness, 1, - "(float flatness) -> None"}, + PyDoc_STR("(float flatness) -> None")}, {"CGContextSetAlpha", (PyCFunction)CGContextRefObj_CGContextSetAlpha, 1, - "(float alpha) -> None"}, + PyDoc_STR("(float alpha) -> None")}, {"CGContextBeginPath", (PyCFunction)CGContextRefObj_CGContextBeginPath, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CGContextMoveToPoint", (PyCFunction)CGContextRefObj_CGContextMoveToPoint, 1, - "(float x, float y) -> None"}, + PyDoc_STR("(float x, float y) -> None")}, {"CGContextAddLineToPoint", (PyCFunction)CGContextRefObj_CGContextAddLineToPoint, 1, - "(float x, float y) -> None"}, + PyDoc_STR("(float x, float y) -> None")}, {"CGContextAddCurveToPoint", (PyCFunction)CGContextRefObj_CGContextAddCurveToPoint, 1, - "(float cp1x, float cp1y, float cp2x, float cp2y, float x, float y) -> None"}, + PyDoc_STR("(float cp1x, float cp1y, float cp2x, float cp2y, float x, float y) -> None")}, {"CGContextAddQuadCurveToPoint", (PyCFunction)CGContextRefObj_CGContextAddQuadCurveToPoint, 1, - "(float cpx, float cpy, float x, float y) -> None"}, + PyDoc_STR("(float cpx, float cpy, float x, float y) -> None")}, {"CGContextClosePath", (PyCFunction)CGContextRefObj_CGContextClosePath, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CGContextAddRect", (PyCFunction)CGContextRefObj_CGContextAddRect, 1, - "(CGRect rect) -> None"}, + PyDoc_STR("(CGRect rect) -> None")}, {"CGContextAddArc", (PyCFunction)CGContextRefObj_CGContextAddArc, 1, - "(float x, float y, float radius, float startAngle, float endAngle, int clockwise) -> None"}, + PyDoc_STR("(float x, float y, float radius, float startAngle, float endAngle, int clockwise) -> None")}, {"CGContextAddArcToPoint", (PyCFunction)CGContextRefObj_CGContextAddArcToPoint, 1, - "(float x1, float y1, float x2, float y2, float radius) -> None"}, + PyDoc_STR("(float x1, float y1, float x2, float y2, float radius) -> None")}, {"CGContextIsPathEmpty", (PyCFunction)CGContextRefObj_CGContextIsPathEmpty, 1, - "() -> (int _rv)"}, + PyDoc_STR("() -> (int _rv)")}, {"CGContextGetPathCurrentPoint", (PyCFunction)CGContextRefObj_CGContextGetPathCurrentPoint, 1, - "() -> (CGPoint _rv)"}, + PyDoc_STR("() -> (CGPoint _rv)")}, {"CGContextGetPathBoundingBox", (PyCFunction)CGContextRefObj_CGContextGetPathBoundingBox, 1, - "() -> (CGRect _rv)"}, + PyDoc_STR("() -> (CGRect _rv)")}, {"CGContextDrawPath", (PyCFunction)CGContextRefObj_CGContextDrawPath, 1, - "(int mode) -> None"}, + PyDoc_STR("(int mode) -> None")}, {"CGContextFillPath", (PyCFunction)CGContextRefObj_CGContextFillPath, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CGContextEOFillPath", (PyCFunction)CGContextRefObj_CGContextEOFillPath, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CGContextStrokePath", (PyCFunction)CGContextRefObj_CGContextStrokePath, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CGContextFillRect", (PyCFunction)CGContextRefObj_CGContextFillRect, 1, - "(CGRect rect) -> None"}, + PyDoc_STR("(CGRect rect) -> None")}, {"CGContextStrokeRect", (PyCFunction)CGContextRefObj_CGContextStrokeRect, 1, - "(CGRect rect) -> None"}, + PyDoc_STR("(CGRect rect) -> None")}, {"CGContextStrokeRectWithWidth", (PyCFunction)CGContextRefObj_CGContextStrokeRectWithWidth, 1, - "(CGRect rect, float width) -> None"}, + PyDoc_STR("(CGRect rect, float width) -> None")}, {"CGContextClearRect", (PyCFunction)CGContextRefObj_CGContextClearRect, 1, - "(CGRect rect) -> None"}, + PyDoc_STR("(CGRect rect) -> None")}, {"CGContextClip", (PyCFunction)CGContextRefObj_CGContextClip, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CGContextEOClip", (PyCFunction)CGContextRefObj_CGContextEOClip, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CGContextClipToRect", (PyCFunction)CGContextRefObj_CGContextClipToRect, 1, - "(CGRect rect) -> None"}, + PyDoc_STR("(CGRect rect) -> None")}, {"CGContextSetGrayFillColor", (PyCFunction)CGContextRefObj_CGContextSetGrayFillColor, 1, - "(float gray, float alpha) -> None"}, + PyDoc_STR("(float gray, float alpha) -> None")}, {"CGContextSetGrayStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetGrayStrokeColor, 1, - "(float gray, float alpha) -> None"}, + PyDoc_STR("(float gray, float alpha) -> None")}, {"CGContextSetRGBFillColor", (PyCFunction)CGContextRefObj_CGContextSetRGBFillColor, 1, - "(float r, float g, float b, float alpha) -> None"}, + PyDoc_STR("(float r, float g, float b, float alpha) -> None")}, {"CGContextSetRGBStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetRGBStrokeColor, 1, - "(float r, float g, float b, float alpha) -> None"}, + PyDoc_STR("(float r, float g, float b, float alpha) -> None")}, {"CGContextSetCMYKFillColor", (PyCFunction)CGContextRefObj_CGContextSetCMYKFillColor, 1, - "(float c, float m, float y, float k, float alpha) -> None"}, + PyDoc_STR("(float c, float m, float y, float k, float alpha) -> None")}, {"CGContextSetCMYKStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetCMYKStrokeColor, 1, - "(float c, float m, float y, float k, float alpha) -> None"}, + PyDoc_STR("(float c, float m, float y, float k, float alpha) -> None")}, {"CGContextSetCharacterSpacing", (PyCFunction)CGContextRefObj_CGContextSetCharacterSpacing, 1, - "(float spacing) -> None"}, + PyDoc_STR("(float spacing) -> None")}, {"CGContextSetTextPosition", (PyCFunction)CGContextRefObj_CGContextSetTextPosition, 1, - "(float x, float y) -> None"}, + PyDoc_STR("(float x, float y) -> None")}, {"CGContextGetTextPosition", (PyCFunction)CGContextRefObj_CGContextGetTextPosition, 1, - "() -> (CGPoint _rv)"}, + PyDoc_STR("() -> (CGPoint _rv)")}, {"CGContextSetTextMatrix", (PyCFunction)CGContextRefObj_CGContextSetTextMatrix, 1, - "(CGAffineTransform transform) -> None"}, + PyDoc_STR("(CGAffineTransform transform) -> None")}, {"CGContextGetTextMatrix", (PyCFunction)CGContextRefObj_CGContextGetTextMatrix, 1, - "() -> (CGAffineTransform _rv)"}, + PyDoc_STR("() -> (CGAffineTransform _rv)")}, {"CGContextSetTextDrawingMode", (PyCFunction)CGContextRefObj_CGContextSetTextDrawingMode, 1, - "(int mode) -> None"}, + PyDoc_STR("(int mode) -> None")}, {"CGContextSetFontSize", (PyCFunction)CGContextRefObj_CGContextSetFontSize, 1, - "(float size) -> None"}, + PyDoc_STR("(float size) -> None")}, {"CGContextSelectFont", (PyCFunction)CGContextRefObj_CGContextSelectFont, 1, - "(char * name, float size, int textEncoding) -> None"}, + PyDoc_STR("(char * name, float size, int textEncoding) -> None")}, {"CGContextShowText", (PyCFunction)CGContextRefObj_CGContextShowText, 1, - "(Buffer cstring) -> None"}, + PyDoc_STR("(Buffer cstring) -> None")}, {"CGContextShowTextAtPoint", (PyCFunction)CGContextRefObj_CGContextShowTextAtPoint, 1, - "(float x, float y, Buffer cstring) -> None"}, + PyDoc_STR("(float x, float y, Buffer cstring) -> None")}, {"CGContextEndPage", (PyCFunction)CGContextRefObj_CGContextEndPage, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CGContextFlush", (PyCFunction)CGContextRefObj_CGContextFlush, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CGContextSynchronize", (PyCFunction)CGContextRefObj_CGContextSynchronize, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CGContextSetShouldAntialias", (PyCFunction)CGContextRefObj_CGContextSetShouldAntialias, 1, - "(int shouldAntialias) -> None"}, + PyDoc_STR("(int shouldAntialias) -> None")}, {"SyncCGContextOriginWithPort", (PyCFunction)CGContextRefObj_SyncCGContextOriginWithPort, 1, - "(CGrafPtr port) -> None"}, + PyDoc_STR("(CGrafPtr port) -> None")}, {"ClipCGContextToRegion", (PyCFunction)CGContextRefObj_ClipCGContextToRegion, 1, - "(Rect portRect, RgnHandle region) -> None"}, + PyDoc_STR("(Rect portRect, RgnHandle region) -> None")}, {NULL, NULL, 0} }; @@ -1323,7 +1323,7 @@ static PyObject *CG_CreateCGContextForPort(PyObject *_self, PyObject *_args) static PyMethodDef CG_methods[] = { {"CreateCGContextForPort", (PyCFunction)CG_CreateCGContextForPort, 1, - "(CGrafPtr) -> CGContextRef"}, + PyDoc_STR("(CGrafPtr) -> CGContextRef")}, {NULL, NULL, 0} }; diff --git a/Mac/Modules/cm/_Cmmodule.c b/Mac/Modules/cm/_Cmmodule.c index d0da473..8ea72f0 100644 --- a/Mac/Modules/cm/_Cmmodule.c +++ b/Mac/Modules/cm/_Cmmodule.c @@ -277,31 +277,31 @@ static PyObject *CmpInstObj_ComponentSetTarget(ComponentInstanceObject *_self, P static PyMethodDef CmpInstObj_methods[] = { {"CloseComponent", (PyCFunction)CmpInstObj_CloseComponent, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"GetComponentInstanceError", (PyCFunction)CmpInstObj_GetComponentInstanceError, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"SetComponentInstanceError", (PyCFunction)CmpInstObj_SetComponentInstanceError, 1, - "(OSErr theError) -> None"}, + PyDoc_STR("(OSErr theError) -> None")}, {"GetComponentInstanceStorage", (PyCFunction)CmpInstObj_GetComponentInstanceStorage, 1, - "() -> (Handle _rv)"}, + PyDoc_STR("() -> (Handle _rv)")}, {"SetComponentInstanceStorage", (PyCFunction)CmpInstObj_SetComponentInstanceStorage, 1, - "(Handle theStorage) -> None"}, + PyDoc_STR("(Handle theStorage) -> None")}, #if !TARGET_API_MAC_CARBON {"GetComponentInstanceA5", (PyCFunction)CmpInstObj_GetComponentInstanceA5, 1, - "() -> (long _rv)"}, + PyDoc_STR("() -> (long _rv)")}, #endif #if !TARGET_API_MAC_CARBON {"SetComponentInstanceA5", (PyCFunction)CmpInstObj_SetComponentInstanceA5, 1, - "(long theA5) -> None"}, + PyDoc_STR("(long theA5) -> None")}, #endif {"ComponentFunctionImplemented", (PyCFunction)CmpInstObj_ComponentFunctionImplemented, 1, - "(short ftnNumber) -> (long _rv)"}, + PyDoc_STR("(short ftnNumber) -> (long _rv)")}, {"GetComponentVersion", (PyCFunction)CmpInstObj_GetComponentVersion, 1, - "() -> (long _rv)"}, + PyDoc_STR("() -> (long _rv)")}, {"ComponentSetTarget", (PyCFunction)CmpInstObj_ComponentSetTarget, 1, - "(ComponentInstance target) -> (long _rv)"}, + PyDoc_STR("(ComponentInstance target) -> (long _rv)")}, {NULL, NULL, 0} }; @@ -669,35 +669,35 @@ static PyObject *CmpObj_GetComponentIconSuite(ComponentObject *_self, PyObject * static PyMethodDef CmpObj_methods[] = { {"UnregisterComponent", (PyCFunction)CmpObj_UnregisterComponent, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"GetComponentInfo", (PyCFunction)CmpObj_GetComponentInfo, 1, - "(Handle componentName, Handle componentInfo, Handle componentIcon) -> (ComponentDescription cd)"}, + PyDoc_STR("(Handle componentName, Handle componentInfo, Handle componentIcon) -> (ComponentDescription cd)")}, {"OpenComponent", (PyCFunction)CmpObj_OpenComponent, 1, - "() -> (ComponentInstance _rv)"}, + PyDoc_STR("() -> (ComponentInstance _rv)")}, {"ResolveComponentAlias", (PyCFunction)CmpObj_ResolveComponentAlias, 1, - "() -> (Component _rv)"}, + PyDoc_STR("() -> (Component _rv)")}, {"GetComponentPublicIndString", (PyCFunction)CmpObj_GetComponentPublicIndString, 1, - "(Str255 theString, short strListID, short index) -> None"}, + PyDoc_STR("(Str255 theString, short strListID, short index) -> None")}, {"GetComponentRefcon", (PyCFunction)CmpObj_GetComponentRefcon, 1, - "() -> (long _rv)"}, + PyDoc_STR("() -> (long _rv)")}, {"SetComponentRefcon", (PyCFunction)CmpObj_SetComponentRefcon, 1, - "(long theRefcon) -> None"}, + PyDoc_STR("(long theRefcon) -> None")}, {"OpenComponentResFile", (PyCFunction)CmpObj_OpenComponentResFile, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, {"GetComponentResource", (PyCFunction)CmpObj_GetComponentResource, 1, - "(OSType resType, short resID) -> (Handle theResource)"}, + PyDoc_STR("(OSType resType, short resID) -> (Handle theResource)")}, {"GetComponentIndString", (PyCFunction)CmpObj_GetComponentIndString, 1, - "(Str255 theString, short strListID, short index) -> None"}, + PyDoc_STR("(Str255 theString, short strListID, short index) -> None")}, {"CountComponentInstances", (PyCFunction)CmpObj_CountComponentInstances, 1, - "() -> (long _rv)"}, + PyDoc_STR("() -> (long _rv)")}, {"SetDefaultComponent", (PyCFunction)CmpObj_SetDefaultComponent, 1, - "(short flags) -> None"}, + PyDoc_STR("(short flags) -> None")}, {"CaptureComponent", (PyCFunction)CmpObj_CaptureComponent, 1, - "(Component capturingComponent) -> (Component _rv)"}, + PyDoc_STR("(Component capturingComponent) -> (Component _rv)")}, {"UncaptureComponent", (PyCFunction)CmpObj_UncaptureComponent, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"GetComponentIconSuite", (PyCFunction)CmpObj_GetComponentIconSuite, 1, - "() -> (Handle iconSuite)"}, + PyDoc_STR("() -> (Handle iconSuite)")}, {NULL, NULL, 0} }; @@ -870,19 +870,19 @@ static PyObject *Cm_RegisterComponentResourceFile(PyObject *_self, PyObject *_ar static PyMethodDef Cm_methods[] = { {"RegisterComponentResource", (PyCFunction)Cm_RegisterComponentResource, 1, - "(ComponentResourceHandle cr, short global) -> (Component _rv)"}, + PyDoc_STR("(ComponentResourceHandle cr, short global) -> (Component _rv)")}, {"FindNextComponent", (PyCFunction)Cm_FindNextComponent, 1, - "(Component aComponent, ComponentDescription looking) -> (Component _rv)"}, + PyDoc_STR("(Component aComponent, ComponentDescription looking) -> (Component _rv)")}, {"CountComponents", (PyCFunction)Cm_CountComponents, 1, - "(ComponentDescription looking) -> (long _rv)"}, + PyDoc_STR("(ComponentDescription looking) -> (long _rv)")}, {"GetComponentListModSeed", (PyCFunction)Cm_GetComponentListModSeed, 1, - "() -> (long _rv)"}, + PyDoc_STR("() -> (long _rv)")}, {"CloseComponentResFile", (PyCFunction)Cm_CloseComponentResFile, 1, - "(short refnum) -> None"}, + PyDoc_STR("(short refnum) -> None")}, {"OpenDefaultComponent", (PyCFunction)Cm_OpenDefaultComponent, 1, - "(OSType componentType, OSType componentSubType) -> (ComponentInstance _rv)"}, + PyDoc_STR("(OSType componentType, OSType componentSubType) -> (ComponentInstance _rv)")}, {"RegisterComponentResourceFile", (PyCFunction)Cm_RegisterComponentResourceFile, 1, - "(short resRefNum, short global) -> (long _rv)"}, + PyDoc_STR("(short resRefNum, short global) -> (long _rv)")}, {NULL, NULL, 0} }; diff --git a/Mac/Modules/ctl/_Ctlmodule.c b/Mac/Modules/ctl/_Ctlmodule.c index cde42b7..0f88370 100644 --- a/Mac/Modules/ctl/_Ctlmodule.c +++ b/Mac/Modules/ctl/_Ctlmodule.c @@ -3880,665 +3880,665 @@ static PyObject *CtlObj_SetPopupData(ControlObject *_self, PyObject *_args) static PyMethodDef CtlObj_methods[] = { {"HiliteControl", (PyCFunction)CtlObj_HiliteControl, 1, - "(ControlPartCode hiliteState) -> None"}, + PyDoc_STR("(ControlPartCode hiliteState) -> None")}, {"ShowControl", (PyCFunction)CtlObj_ShowControl, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"HideControl", (PyCFunction)CtlObj_HideControl, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"IsControlActive", (PyCFunction)CtlObj_IsControlActive, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, {"IsControlVisible", (PyCFunction)CtlObj_IsControlVisible, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, {"ActivateControl", (PyCFunction)CtlObj_ActivateControl, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"DeactivateControl", (PyCFunction)CtlObj_DeactivateControl, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"SetControlVisibility", (PyCFunction)CtlObj_SetControlVisibility, 1, - "(Boolean inIsVisible, Boolean inDoDraw) -> None"}, + PyDoc_STR("(Boolean inIsVisible, Boolean inDoDraw) -> None")}, #if TARGET_API_MAC_OSX {"IsControlEnabled", (PyCFunction)CtlObj_IsControlEnabled, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, #endif #if TARGET_API_MAC_OSX {"EnableControl", (PyCFunction)CtlObj_EnableControl, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if TARGET_API_MAC_OSX {"DisableControl", (PyCFunction)CtlObj_DisableControl, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif {"Draw1Control", (PyCFunction)CtlObj_Draw1Control, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"GetBestControlRect", (PyCFunction)CtlObj_GetBestControlRect, 1, - "() -> (Rect outRect, SInt16 outBaseLineOffset)"}, + PyDoc_STR("() -> (Rect outRect, SInt16 outBaseLineOffset)")}, {"SetControlFontStyle", (PyCFunction)CtlObj_SetControlFontStyle, 1, - "(ControlFontStyleRec inStyle) -> None"}, + PyDoc_STR("(ControlFontStyleRec inStyle) -> None")}, {"DrawControlInCurrentPort", (PyCFunction)CtlObj_DrawControlInCurrentPort, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"SetUpControlBackground", (PyCFunction)CtlObj_SetUpControlBackground, 1, - "(SInt16 inDepth, Boolean inIsColorDevice) -> None"}, + PyDoc_STR("(SInt16 inDepth, Boolean inIsColorDevice) -> None")}, {"SetUpControlTextColor", (PyCFunction)CtlObj_SetUpControlTextColor, 1, - "(SInt16 inDepth, Boolean inIsColorDevice) -> None"}, + PyDoc_STR("(SInt16 inDepth, Boolean inIsColorDevice) -> None")}, {"DragControl", (PyCFunction)CtlObj_DragControl, 1, - "(Point startPoint, Rect limitRect, Rect slopRect, DragConstraint axis) -> None"}, + PyDoc_STR("(Point startPoint, Rect limitRect, Rect slopRect, DragConstraint axis) -> None")}, {"TestControl", (PyCFunction)CtlObj_TestControl, 1, - "(Point testPoint) -> (ControlPartCode _rv)"}, + PyDoc_STR("(Point testPoint) -> (ControlPartCode _rv)")}, #if TARGET_API_MAC_CARBON {"HandleControlContextualMenuClick", (PyCFunction)CtlObj_HandleControlContextualMenuClick, 1, - "(Point inWhere) -> (Boolean menuDisplayed)"}, + PyDoc_STR("(Point inWhere) -> (Boolean menuDisplayed)")}, #endif #if TARGET_API_MAC_CARBON {"GetControlClickActivation", (PyCFunction)CtlObj_GetControlClickActivation, 1, - "(Point inWhere, EventModifiers inModifiers) -> (ClickActivationResult outResult)"}, + PyDoc_STR("(Point inWhere, EventModifiers inModifiers) -> (ClickActivationResult outResult)")}, #endif {"HandleControlKey", (PyCFunction)CtlObj_HandleControlKey, 1, - "(SInt16 inKeyCode, SInt16 inCharCode, EventModifiers inModifiers) -> (ControlPartCode _rv)"}, + PyDoc_STR("(SInt16 inKeyCode, SInt16 inCharCode, EventModifiers inModifiers) -> (ControlPartCode _rv)")}, #if TARGET_API_MAC_CARBON {"HandleControlSetCursor", (PyCFunction)CtlObj_HandleControlSetCursor, 1, - "(Point localPoint, EventModifiers modifiers) -> (Boolean cursorWasSet)"}, + PyDoc_STR("(Point localPoint, EventModifiers modifiers) -> (Boolean cursorWasSet)")}, #endif {"MoveControl", (PyCFunction)CtlObj_MoveControl, 1, - "(SInt16 h, SInt16 v) -> None"}, + PyDoc_STR("(SInt16 h, SInt16 v) -> None")}, {"SizeControl", (PyCFunction)CtlObj_SizeControl, 1, - "(SInt16 w, SInt16 h) -> None"}, + PyDoc_STR("(SInt16 w, SInt16 h) -> None")}, {"SetControlTitle", (PyCFunction)CtlObj_SetControlTitle, 1, - "(Str255 title) -> None"}, + PyDoc_STR("(Str255 title) -> None")}, {"GetControlTitle", (PyCFunction)CtlObj_GetControlTitle, 1, - "() -> (Str255 title)"}, + PyDoc_STR("() -> (Str255 title)")}, #if TARGET_API_MAC_CARBON {"SetControlTitleWithCFString", (PyCFunction)CtlObj_SetControlTitleWithCFString, 1, - "(CFStringRef inString) -> None"}, + PyDoc_STR("(CFStringRef inString) -> None")}, #endif #if TARGET_API_MAC_CARBON {"CopyControlTitleAsCFString", (PyCFunction)CtlObj_CopyControlTitleAsCFString, 1, - "() -> (CFStringRef outString)"}, + PyDoc_STR("() -> (CFStringRef outString)")}, #endif {"GetControlValue", (PyCFunction)CtlObj_GetControlValue, 1, - "() -> (SInt16 _rv)"}, + PyDoc_STR("() -> (SInt16 _rv)")}, {"SetControlValue", (PyCFunction)CtlObj_SetControlValue, 1, - "(SInt16 newValue) -> None"}, + PyDoc_STR("(SInt16 newValue) -> None")}, {"GetControlMinimum", (PyCFunction)CtlObj_GetControlMinimum, 1, - "() -> (SInt16 _rv)"}, + PyDoc_STR("() -> (SInt16 _rv)")}, {"SetControlMinimum", (PyCFunction)CtlObj_SetControlMinimum, 1, - "(SInt16 newMinimum) -> None"}, + PyDoc_STR("(SInt16 newMinimum) -> None")}, {"GetControlMaximum", (PyCFunction)CtlObj_GetControlMaximum, 1, - "() -> (SInt16 _rv)"}, + PyDoc_STR("() -> (SInt16 _rv)")}, {"SetControlMaximum", (PyCFunction)CtlObj_SetControlMaximum, 1, - "(SInt16 newMaximum) -> None"}, + PyDoc_STR("(SInt16 newMaximum) -> None")}, {"GetControlViewSize", (PyCFunction)CtlObj_GetControlViewSize, 1, - "() -> (SInt32 _rv)"}, + PyDoc_STR("() -> (SInt32 _rv)")}, {"SetControlViewSize", (PyCFunction)CtlObj_SetControlViewSize, 1, - "(SInt32 newViewSize) -> None"}, + PyDoc_STR("(SInt32 newViewSize) -> None")}, {"GetControl32BitValue", (PyCFunction)CtlObj_GetControl32BitValue, 1, - "() -> (SInt32 _rv)"}, + PyDoc_STR("() -> (SInt32 _rv)")}, {"SetControl32BitValue", (PyCFunction)CtlObj_SetControl32BitValue, 1, - "(SInt32 newValue) -> None"}, + PyDoc_STR("(SInt32 newValue) -> None")}, {"GetControl32BitMaximum", (PyCFunction)CtlObj_GetControl32BitMaximum, 1, - "() -> (SInt32 _rv)"}, + PyDoc_STR("() -> (SInt32 _rv)")}, {"SetControl32BitMaximum", (PyCFunction)CtlObj_SetControl32BitMaximum, 1, - "(SInt32 newMaximum) -> None"}, + PyDoc_STR("(SInt32 newMaximum) -> None")}, {"GetControl32BitMinimum", (PyCFunction)CtlObj_GetControl32BitMinimum, 1, - "() -> (SInt32 _rv)"}, + PyDoc_STR("() -> (SInt32 _rv)")}, {"SetControl32BitMinimum", (PyCFunction)CtlObj_SetControl32BitMinimum, 1, - "(SInt32 newMinimum) -> None"}, + PyDoc_STR("(SInt32 newMinimum) -> None")}, {"IsValidControlHandle", (PyCFunction)CtlObj_IsValidControlHandle, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, #if TARGET_API_MAC_CARBON {"SetControlID", (PyCFunction)CtlObj_SetControlID, 1, - "(ControlID inID) -> None"}, + PyDoc_STR("(ControlID inID) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetControlID", (PyCFunction)CtlObj_GetControlID, 1, - "() -> (ControlID outID)"}, + PyDoc_STR("() -> (ControlID outID)")}, #endif #if TARGET_API_MAC_CARBON {"SetControlCommandID", (PyCFunction)CtlObj_SetControlCommandID, 1, - "(UInt32 inCommandID) -> None"}, + PyDoc_STR("(UInt32 inCommandID) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetControlCommandID", (PyCFunction)CtlObj_GetControlCommandID, 1, - "() -> (UInt32 outCommandID)"}, + PyDoc_STR("() -> (UInt32 outCommandID)")}, #endif {"RemoveControlProperty", (PyCFunction)CtlObj_RemoveControlProperty, 1, - "(OSType propertyCreator, OSType propertyTag) -> None"}, + PyDoc_STR("(OSType propertyCreator, OSType propertyTag) -> None")}, #if TARGET_API_MAC_CARBON {"GetControlPropertyAttributes", (PyCFunction)CtlObj_GetControlPropertyAttributes, 1, - "(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)"}, + PyDoc_STR("(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)")}, #endif #if TARGET_API_MAC_CARBON {"ChangeControlPropertyAttributes", (PyCFunction)CtlObj_ChangeControlPropertyAttributes, 1, - "(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None"}, + PyDoc_STR("(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None")}, #endif {"GetControlRegion", (PyCFunction)CtlObj_GetControlRegion, 1, - "(ControlPartCode inPart, RgnHandle outRegion) -> None"}, + PyDoc_STR("(ControlPartCode inPart, RgnHandle outRegion) -> None")}, {"GetControlVariant", (PyCFunction)CtlObj_GetControlVariant, 1, - "() -> (ControlVariant _rv)"}, + PyDoc_STR("() -> (ControlVariant _rv)")}, {"SetControlAction", (PyCFunction)CtlObj_SetControlAction, 1, - "(PyObject* actionProc) -> None"}, + PyDoc_STR("(PyObject* actionProc) -> None")}, {"SetControlReference", (PyCFunction)CtlObj_SetControlReference, 1, - "(SInt32 data) -> None"}, + PyDoc_STR("(SInt32 data) -> None")}, {"GetControlReference", (PyCFunction)CtlObj_GetControlReference, 1, - "() -> (SInt32 _rv)"}, + PyDoc_STR("() -> (SInt32 _rv)")}, #if !TARGET_API_MAC_CARBON {"GetAuxiliaryControlRecord", (PyCFunction)CtlObj_GetAuxiliaryControlRecord, 1, - "() -> (Boolean _rv, AuxCtlHandle acHndl)"}, + PyDoc_STR("() -> (Boolean _rv, AuxCtlHandle acHndl)")}, #endif #if !TARGET_API_MAC_CARBON {"SetControlColor", (PyCFunction)CtlObj_SetControlColor, 1, - "(CCTabHandle newColorTable) -> None"}, + PyDoc_STR("(CCTabHandle newColorTable) -> None")}, #endif {"EmbedControl", (PyCFunction)CtlObj_EmbedControl, 1, - "(ControlHandle inContainer) -> None"}, + PyDoc_STR("(ControlHandle inContainer) -> None")}, {"AutoEmbedControl", (PyCFunction)CtlObj_AutoEmbedControl, 1, - "(WindowPtr inWindow) -> None"}, + PyDoc_STR("(WindowPtr inWindow) -> None")}, {"GetSuperControl", (PyCFunction)CtlObj_GetSuperControl, 1, - "() -> (ControlHandle outParent)"}, + PyDoc_STR("() -> (ControlHandle outParent)")}, {"CountSubControls", (PyCFunction)CtlObj_CountSubControls, 1, - "() -> (UInt16 outNumChildren)"}, + PyDoc_STR("() -> (UInt16 outNumChildren)")}, {"GetIndexedSubControl", (PyCFunction)CtlObj_GetIndexedSubControl, 1, - "(UInt16 inIndex) -> (ControlHandle outSubControl)"}, + PyDoc_STR("(UInt16 inIndex) -> (ControlHandle outSubControl)")}, {"SetControlSupervisor", (PyCFunction)CtlObj_SetControlSupervisor, 1, - "(ControlHandle inBoss) -> None"}, + PyDoc_STR("(ControlHandle inBoss) -> None")}, {"GetControlFeatures", (PyCFunction)CtlObj_GetControlFeatures, 1, - "() -> (UInt32 outFeatures)"}, + PyDoc_STR("() -> (UInt32 outFeatures)")}, {"GetControlDataSize", (PyCFunction)CtlObj_GetControlDataSize, 1, - "(ControlPartCode inPart, ResType inTagName) -> (Size outMaxSize)"}, + PyDoc_STR("(ControlPartCode inPart, ResType inTagName) -> (Size outMaxSize)")}, #if TARGET_API_MAC_CARBON {"HandleControlDragTracking", (PyCFunction)CtlObj_HandleControlDragTracking, 1, - "(DragTrackingMessage inMessage, DragReference inDrag) -> (Boolean outLikesDrag)"}, + PyDoc_STR("(DragTrackingMessage inMessage, DragReference inDrag) -> (Boolean outLikesDrag)")}, #endif #if TARGET_API_MAC_CARBON {"HandleControlDragReceive", (PyCFunction)CtlObj_HandleControlDragReceive, 1, - "(DragReference inDrag) -> None"}, + PyDoc_STR("(DragReference inDrag) -> None")}, #endif #if TARGET_API_MAC_CARBON {"SetControlDragTrackingEnabled", (PyCFunction)CtlObj_SetControlDragTrackingEnabled, 1, - "(Boolean tracks) -> None"}, + PyDoc_STR("(Boolean tracks) -> None")}, #endif #if TARGET_API_MAC_CARBON {"IsControlDragTrackingEnabled", (PyCFunction)CtlObj_IsControlDragTrackingEnabled, 1, - "() -> (Boolean tracks)"}, + PyDoc_STR("() -> (Boolean tracks)")}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"GetControlBounds", (PyCFunction)CtlObj_GetControlBounds, 1, - "() -> (Rect bounds)"}, + PyDoc_STR("() -> (Rect bounds)")}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"IsControlHilited", (PyCFunction)CtlObj_IsControlHilited, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"GetControlHilite", (PyCFunction)CtlObj_GetControlHilite, 1, - "() -> (UInt16 _rv)"}, + PyDoc_STR("() -> (UInt16 _rv)")}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"GetControlOwner", (PyCFunction)CtlObj_GetControlOwner, 1, - "() -> (WindowPtr _rv)"}, + PyDoc_STR("() -> (WindowPtr _rv)")}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"GetControlDataHandle", (PyCFunction)CtlObj_GetControlDataHandle, 1, - "() -> (Handle _rv)"}, + PyDoc_STR("() -> (Handle _rv)")}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"GetControlPopupMenuHandle", (PyCFunction)CtlObj_GetControlPopupMenuHandle, 1, - "() -> (MenuHandle _rv)"}, + PyDoc_STR("() -> (MenuHandle _rv)")}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"GetControlPopupMenuID", (PyCFunction)CtlObj_GetControlPopupMenuID, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"SetControlDataHandle", (PyCFunction)CtlObj_SetControlDataHandle, 1, - "(Handle dataHandle) -> None"}, + PyDoc_STR("(Handle dataHandle) -> None")}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"SetControlBounds", (PyCFunction)CtlObj_SetControlBounds, 1, - "(Rect bounds) -> None"}, + PyDoc_STR("(Rect bounds) -> None")}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"SetControlPopupMenuHandle", (PyCFunction)CtlObj_SetControlPopupMenuHandle, 1, - "(MenuHandle popupMenu) -> None"}, + PyDoc_STR("(MenuHandle popupMenu) -> None")}, #endif #if ACCESSOR_CALLS_ARE_FUNCTIONS {"SetControlPopupMenuID", (PyCFunction)CtlObj_SetControlPopupMenuID, 1, - "(short menuID) -> None"}, + PyDoc_STR("(short menuID) -> None")}, #endif {"GetBevelButtonMenuValue", (PyCFunction)CtlObj_GetBevelButtonMenuValue, 1, - "() -> (SInt16 outValue)"}, + PyDoc_STR("() -> (SInt16 outValue)")}, {"SetBevelButtonMenuValue", (PyCFunction)CtlObj_SetBevelButtonMenuValue, 1, - "(SInt16 inValue) -> None"}, + PyDoc_STR("(SInt16 inValue) -> None")}, {"GetBevelButtonMenuHandle", (PyCFunction)CtlObj_GetBevelButtonMenuHandle, 1, - "() -> (MenuHandle outHandle)"}, + PyDoc_STR("() -> (MenuHandle outHandle)")}, #if TARGET_API_MAC_CARBON {"SetBevelButtonContentInfo", (PyCFunction)CtlObj_SetBevelButtonContentInfo, 1, - "(ControlButtonContentInfo inContent) -> None"}, + PyDoc_STR("(ControlButtonContentInfo inContent) -> None")}, #endif {"SetBevelButtonTransform", (PyCFunction)CtlObj_SetBevelButtonTransform, 1, - "(IconTransformType transform) -> None"}, + PyDoc_STR("(IconTransformType transform) -> None")}, {"SetDisclosureTriangleLastValue", (PyCFunction)CtlObj_SetDisclosureTriangleLastValue, 1, - "(SInt16 inValue) -> None"}, + PyDoc_STR("(SInt16 inValue) -> None")}, {"GetTabContentRect", (PyCFunction)CtlObj_GetTabContentRect, 1, - "() -> (Rect outContentRect)"}, + PyDoc_STR("() -> (Rect outContentRect)")}, {"SetTabEnabled", (PyCFunction)CtlObj_SetTabEnabled, 1, - "(SInt16 inTabToHilite, Boolean inEnabled) -> None"}, + PyDoc_STR("(SInt16 inTabToHilite, Boolean inEnabled) -> None")}, #if TARGET_API_MAC_CARBON {"SetImageWellContentInfo", (PyCFunction)CtlObj_SetImageWellContentInfo, 1, - "(ControlButtonContentInfo inContent) -> None"}, + PyDoc_STR("(ControlButtonContentInfo inContent) -> None")}, #endif {"SetImageWellTransform", (PyCFunction)CtlObj_SetImageWellTransform, 1, - "(IconTransformType inTransform) -> None"}, + PyDoc_STR("(IconTransformType inTransform) -> None")}, #if TARGET_API_MAC_CARBON {"GetDataBrowserViewStyle", (PyCFunction)CtlObj_GetDataBrowserViewStyle, 1, - "() -> (OSType style)"}, + PyDoc_STR("() -> (OSType style)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserViewStyle", (PyCFunction)CtlObj_SetDataBrowserViewStyle, 1, - "(OSType style) -> None"}, + PyDoc_STR("(OSType style) -> None")}, #endif #if TARGET_API_MAC_CARBON {"EnableDataBrowserEditCommand", (PyCFunction)CtlObj_EnableDataBrowserEditCommand, 1, - "(UInt32 command) -> (Boolean _rv)"}, + PyDoc_STR("(UInt32 command) -> (Boolean _rv)")}, #endif #if TARGET_API_MAC_CARBON {"ExecuteDataBrowserEditCommand", (PyCFunction)CtlObj_ExecuteDataBrowserEditCommand, 1, - "(UInt32 command) -> None"}, + PyDoc_STR("(UInt32 command) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserSelectionAnchor", (PyCFunction)CtlObj_GetDataBrowserSelectionAnchor, 1, - "() -> (UInt32 first, UInt32 last)"}, + PyDoc_STR("() -> (UInt32 first, UInt32 last)")}, #endif #if TARGET_API_MAC_CARBON {"MoveDataBrowserSelectionAnchor", (PyCFunction)CtlObj_MoveDataBrowserSelectionAnchor, 1, - "(UInt32 direction, Boolean extendSelection) -> None"}, + PyDoc_STR("(UInt32 direction, Boolean extendSelection) -> None")}, #endif #if TARGET_API_MAC_CARBON {"OpenDataBrowserContainer", (PyCFunction)CtlObj_OpenDataBrowserContainer, 1, - "(UInt32 container) -> None"}, + PyDoc_STR("(UInt32 container) -> None")}, #endif #if TARGET_API_MAC_CARBON {"CloseDataBrowserContainer", (PyCFunction)CtlObj_CloseDataBrowserContainer, 1, - "(UInt32 container) -> None"}, + PyDoc_STR("(UInt32 container) -> None")}, #endif #if TARGET_API_MAC_CARBON {"SortDataBrowserContainer", (PyCFunction)CtlObj_SortDataBrowserContainer, 1, - "(UInt32 container, Boolean sortChildren) -> None"}, + PyDoc_STR("(UInt32 container, Boolean sortChildren) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserItems", (PyCFunction)CtlObj_GetDataBrowserItems, 1, - "(UInt32 container, Boolean recurse, UInt32 state, Handle items) -> None"}, + PyDoc_STR("(UInt32 container, Boolean recurse, UInt32 state, Handle items) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserItemCount", (PyCFunction)CtlObj_GetDataBrowserItemCount, 1, - "(UInt32 container, Boolean recurse, UInt32 state) -> (UInt32 numItems)"}, + PyDoc_STR("(UInt32 container, Boolean recurse, UInt32 state) -> (UInt32 numItems)")}, #endif #if TARGET_API_MAC_CARBON {"IsDataBrowserItemSelected", (PyCFunction)CtlObj_IsDataBrowserItemSelected, 1, - "(UInt32 item) -> (Boolean _rv)"}, + PyDoc_STR("(UInt32 item) -> (Boolean _rv)")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserItemState", (PyCFunction)CtlObj_GetDataBrowserItemState, 1, - "(UInt32 item) -> (UInt32 state)"}, + PyDoc_STR("(UInt32 item) -> (UInt32 state)")}, #endif #if TARGET_API_MAC_CARBON {"RevealDataBrowserItem", (PyCFunction)CtlObj_RevealDataBrowserItem, 1, - "(UInt32 item, UInt32 propertyID, UInt8 options) -> None"}, + PyDoc_STR("(UInt32 item, UInt32 propertyID, UInt8 options) -> None")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserActiveItems", (PyCFunction)CtlObj_SetDataBrowserActiveItems, 1, - "(Boolean active) -> None"}, + PyDoc_STR("(Boolean active) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserActiveItems", (PyCFunction)CtlObj_GetDataBrowserActiveItems, 1, - "() -> (Boolean active)"}, + PyDoc_STR("() -> (Boolean active)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserScrollBarInset", (PyCFunction)CtlObj_SetDataBrowserScrollBarInset, 1, - "() -> (Rect insetRect)"}, + PyDoc_STR("() -> (Rect insetRect)")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserScrollBarInset", (PyCFunction)CtlObj_GetDataBrowserScrollBarInset, 1, - "() -> (Rect insetRect)"}, + PyDoc_STR("() -> (Rect insetRect)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserTarget", (PyCFunction)CtlObj_SetDataBrowserTarget, 1, - "(UInt32 target) -> None"}, + PyDoc_STR("(UInt32 target) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserTarget", (PyCFunction)CtlObj_GetDataBrowserTarget, 1, - "() -> (UInt32 target)"}, + PyDoc_STR("() -> (UInt32 target)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserSortOrder", (PyCFunction)CtlObj_SetDataBrowserSortOrder, 1, - "(UInt16 order) -> None"}, + PyDoc_STR("(UInt16 order) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserSortOrder", (PyCFunction)CtlObj_GetDataBrowserSortOrder, 1, - "() -> (UInt16 order)"}, + PyDoc_STR("() -> (UInt16 order)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserScrollPosition", (PyCFunction)CtlObj_SetDataBrowserScrollPosition, 1, - "(UInt32 top, UInt32 left) -> None"}, + PyDoc_STR("(UInt32 top, UInt32 left) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserScrollPosition", (PyCFunction)CtlObj_GetDataBrowserScrollPosition, 1, - "() -> (UInt32 top, UInt32 left)"}, + PyDoc_STR("() -> (UInt32 top, UInt32 left)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserHasScrollBars", (PyCFunction)CtlObj_SetDataBrowserHasScrollBars, 1, - "(Boolean horiz, Boolean vert) -> None"}, + PyDoc_STR("(Boolean horiz, Boolean vert) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserHasScrollBars", (PyCFunction)CtlObj_GetDataBrowserHasScrollBars, 1, - "() -> (Boolean horiz, Boolean vert)"}, + PyDoc_STR("() -> (Boolean horiz, Boolean vert)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserSortProperty", (PyCFunction)CtlObj_SetDataBrowserSortProperty, 1, - "(UInt32 property) -> None"}, + PyDoc_STR("(UInt32 property) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserSortProperty", (PyCFunction)CtlObj_GetDataBrowserSortProperty, 1, - "() -> (UInt32 property)"}, + PyDoc_STR("() -> (UInt32 property)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserSelectionFlags", (PyCFunction)CtlObj_SetDataBrowserSelectionFlags, 1, - "(UInt32 selectionFlags) -> None"}, + PyDoc_STR("(UInt32 selectionFlags) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserSelectionFlags", (PyCFunction)CtlObj_GetDataBrowserSelectionFlags, 1, - "() -> (UInt32 selectionFlags)"}, + PyDoc_STR("() -> (UInt32 selectionFlags)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserPropertyFlags", (PyCFunction)CtlObj_SetDataBrowserPropertyFlags, 1, - "(UInt32 property, UInt32 flags) -> None"}, + PyDoc_STR("(UInt32 property, UInt32 flags) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserPropertyFlags", (PyCFunction)CtlObj_GetDataBrowserPropertyFlags, 1, - "(UInt32 property) -> (UInt32 flags)"}, + PyDoc_STR("(UInt32 property) -> (UInt32 flags)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserEditText", (PyCFunction)CtlObj_SetDataBrowserEditText, 1, - "(CFStringRef text) -> None"}, + PyDoc_STR("(CFStringRef text) -> None")}, #endif #if TARGET_API_MAC_OSX {"CopyDataBrowserEditText", (PyCFunction)CtlObj_CopyDataBrowserEditText, 1, - "() -> (CFStringRef text)"}, + PyDoc_STR("() -> (CFStringRef text)")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserEditText", (PyCFunction)CtlObj_GetDataBrowserEditText, 1, - "(CFMutableStringRef text) -> None"}, + PyDoc_STR("(CFMutableStringRef text) -> None")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserEditItem", (PyCFunction)CtlObj_SetDataBrowserEditItem, 1, - "(UInt32 item, UInt32 property) -> None"}, + PyDoc_STR("(UInt32 item, UInt32 property) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserEditItem", (PyCFunction)CtlObj_GetDataBrowserEditItem, 1, - "() -> (UInt32 item, UInt32 property)"}, + PyDoc_STR("() -> (UInt32 item, UInt32 property)")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserItemPartBounds", (PyCFunction)CtlObj_GetDataBrowserItemPartBounds, 1, - "(UInt32 item, UInt32 property, OSType part) -> (Rect bounds)"}, + PyDoc_STR("(UInt32 item, UInt32 property, OSType part) -> (Rect bounds)")}, #endif #if TARGET_API_MAC_CARBON {"RemoveDataBrowserTableViewColumn", (PyCFunction)CtlObj_RemoveDataBrowserTableViewColumn, 1, - "(UInt32 column) -> None"}, + PyDoc_STR("(UInt32 column) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserTableViewColumnCount", (PyCFunction)CtlObj_GetDataBrowserTableViewColumnCount, 1, - "() -> (UInt32 numColumns)"}, + PyDoc_STR("() -> (UInt32 numColumns)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserTableViewHiliteStyle", (PyCFunction)CtlObj_SetDataBrowserTableViewHiliteStyle, 1, - "(UInt32 hiliteStyle) -> None"}, + PyDoc_STR("(UInt32 hiliteStyle) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserTableViewHiliteStyle", (PyCFunction)CtlObj_GetDataBrowserTableViewHiliteStyle, 1, - "() -> (UInt32 hiliteStyle)"}, + PyDoc_STR("() -> (UInt32 hiliteStyle)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserTableViewRowHeight", (PyCFunction)CtlObj_SetDataBrowserTableViewRowHeight, 1, - "(UInt16 height) -> None"}, + PyDoc_STR("(UInt16 height) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserTableViewRowHeight", (PyCFunction)CtlObj_GetDataBrowserTableViewRowHeight, 1, - "() -> (UInt16 height)"}, + PyDoc_STR("() -> (UInt16 height)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserTableViewColumnWidth", (PyCFunction)CtlObj_SetDataBrowserTableViewColumnWidth, 1, - "(UInt16 width) -> None"}, + PyDoc_STR("(UInt16 width) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserTableViewColumnWidth", (PyCFunction)CtlObj_GetDataBrowserTableViewColumnWidth, 1, - "() -> (UInt16 width)"}, + PyDoc_STR("() -> (UInt16 width)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserTableViewItemRowHeight", (PyCFunction)CtlObj_SetDataBrowserTableViewItemRowHeight, 1, - "(UInt32 item, UInt16 height) -> None"}, + PyDoc_STR("(UInt32 item, UInt16 height) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserTableViewItemRowHeight", (PyCFunction)CtlObj_GetDataBrowserTableViewItemRowHeight, 1, - "(UInt32 item) -> (UInt16 height)"}, + PyDoc_STR("(UInt32 item) -> (UInt16 height)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserTableViewNamedColumnWidth", (PyCFunction)CtlObj_SetDataBrowserTableViewNamedColumnWidth, 1, - "(UInt32 column, UInt16 width) -> None"}, + PyDoc_STR("(UInt32 column, UInt16 width) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserTableViewNamedColumnWidth", (PyCFunction)CtlObj_GetDataBrowserTableViewNamedColumnWidth, 1, - "(UInt32 column) -> (UInt16 width)"}, + PyDoc_STR("(UInt32 column) -> (UInt16 width)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserTableViewGeometry", (PyCFunction)CtlObj_SetDataBrowserTableViewGeometry, 1, - "(Boolean variableWidthColumns, Boolean variableHeightRows) -> None"}, + PyDoc_STR("(Boolean variableWidthColumns, Boolean variableHeightRows) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserTableViewGeometry", (PyCFunction)CtlObj_GetDataBrowserTableViewGeometry, 1, - "() -> (Boolean variableWidthColumns, Boolean variableHeightRows)"}, + PyDoc_STR("() -> (Boolean variableWidthColumns, Boolean variableHeightRows)")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserTableViewItemID", (PyCFunction)CtlObj_GetDataBrowserTableViewItemID, 1, - "(UInt32 row) -> (UInt32 item)"}, + PyDoc_STR("(UInt32 row) -> (UInt32 item)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserTableViewItemRow", (PyCFunction)CtlObj_SetDataBrowserTableViewItemRow, 1, - "(UInt32 item, UInt32 row) -> None"}, + PyDoc_STR("(UInt32 item, UInt32 row) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserTableViewItemRow", (PyCFunction)CtlObj_GetDataBrowserTableViewItemRow, 1, - "(UInt32 item) -> (UInt32 row)"}, + PyDoc_STR("(UInt32 item) -> (UInt32 row)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserTableViewColumnPosition", (PyCFunction)CtlObj_SetDataBrowserTableViewColumnPosition, 1, - "(UInt32 column, UInt32 position) -> None"}, + PyDoc_STR("(UInt32 column, UInt32 position) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserTableViewColumnPosition", (PyCFunction)CtlObj_GetDataBrowserTableViewColumnPosition, 1, - "(UInt32 column) -> (UInt32 position)"}, + PyDoc_STR("(UInt32 column) -> (UInt32 position)")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserTableViewColumnProperty", (PyCFunction)CtlObj_GetDataBrowserTableViewColumnProperty, 1, - "(UInt32 column) -> (UInt32 property)"}, + PyDoc_STR("(UInt32 column) -> (UInt32 property)")}, #endif #if TARGET_API_MAC_CARBON {"AutoSizeDataBrowserListViewColumns", (PyCFunction)CtlObj_AutoSizeDataBrowserListViewColumns, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if TARGET_API_MAC_CARBON {"AddDataBrowserListViewColumn", (PyCFunction)CtlObj_AddDataBrowserListViewColumn, 1, - "(DataBrowserListViewColumnDesc columnDesc, UInt32 position) -> None"}, + PyDoc_STR("(DataBrowserListViewColumnDesc columnDesc, UInt32 position) -> None")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserListViewHeaderBtnHeight", (PyCFunction)CtlObj_SetDataBrowserListViewHeaderBtnHeight, 1, - "(UInt16 height) -> None"}, + PyDoc_STR("(UInt16 height) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserListViewHeaderBtnHeight", (PyCFunction)CtlObj_GetDataBrowserListViewHeaderBtnHeight, 1, - "() -> (UInt16 height)"}, + PyDoc_STR("() -> (UInt16 height)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserListViewUsePlainBackground", (PyCFunction)CtlObj_SetDataBrowserListViewUsePlainBackground, 1, - "(Boolean usePlainBackground) -> None"}, + PyDoc_STR("(Boolean usePlainBackground) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserListViewUsePlainBackground", (PyCFunction)CtlObj_GetDataBrowserListViewUsePlainBackground, 1, - "() -> (Boolean usePlainBackground)"}, + PyDoc_STR("() -> (Boolean usePlainBackground)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserListViewDisclosureColumn", (PyCFunction)CtlObj_SetDataBrowserListViewDisclosureColumn, 1, - "(UInt32 column, Boolean expandableRows) -> None"}, + PyDoc_STR("(UInt32 column, Boolean expandableRows) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserListViewDisclosureColumn", (PyCFunction)CtlObj_GetDataBrowserListViewDisclosureColumn, 1, - "() -> (UInt32 column, Boolean expandableRows)"}, + PyDoc_STR("() -> (UInt32 column, Boolean expandableRows)")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserColumnViewPath", (PyCFunction)CtlObj_GetDataBrowserColumnViewPath, 1, - "(Handle path) -> None"}, + PyDoc_STR("(Handle path) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserColumnViewPathLength", (PyCFunction)CtlObj_GetDataBrowserColumnViewPathLength, 1, - "() -> (UInt32 pathLength)"}, + PyDoc_STR("() -> (UInt32 pathLength)")}, #endif #if TARGET_API_MAC_CARBON {"SetDataBrowserColumnViewDisplayType", (PyCFunction)CtlObj_SetDataBrowserColumnViewDisplayType, 1, - "(OSType propertyType) -> None"}, + PyDoc_STR("(OSType propertyType) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetDataBrowserColumnViewDisplayType", (PyCFunction)CtlObj_GetDataBrowserColumnViewDisplayType, 1, - "() -> (OSType propertyType)"}, + PyDoc_STR("() -> (OSType propertyType)")}, #endif {"as_Resource", (PyCFunction)CtlObj_as_Resource, 1, - "() -> (Handle _rv)"}, + PyDoc_STR("() -> (Handle _rv)")}, {"GetControlRect", (PyCFunction)CtlObj_GetControlRect, 1, - "() -> (Rect rect)"}, + PyDoc_STR("() -> (Rect rect)")}, {"DisposeControl", (PyCFunction)CtlObj_DisposeControl, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"TrackControl", (PyCFunction)CtlObj_TrackControl, 1, - "(Point startPoint [,trackercallback]) -> (ControlPartCode _rv)"}, + PyDoc_STR("(Point startPoint [,trackercallback]) -> (ControlPartCode _rv)")}, {"HandleControlClick", (PyCFunction)CtlObj_HandleControlClick, 1, - "(Point startPoint, Integer modifiers, [,trackercallback]) -> (ControlPartCode _rv)"}, + PyDoc_STR("(Point startPoint, Integer modifiers, [,trackercallback]) -> (ControlPartCode _rv)")}, {"SetControlData", (PyCFunction)CtlObj_SetControlData, 1, - "(stuff) -> None"}, + PyDoc_STR("(stuff) -> None")}, {"GetControlData", (PyCFunction)CtlObj_GetControlData, 1, - "(part, type) -> String"}, + PyDoc_STR("(part, type) -> String")}, {"SetControlData_Handle", (PyCFunction)CtlObj_SetControlData_Handle, 1, - "(ResObj) -> None"}, + PyDoc_STR("(ResObj) -> None")}, {"GetControlData_Handle", (PyCFunction)CtlObj_GetControlData_Handle, 1, - "(part, type) -> ResObj"}, + PyDoc_STR("(part, type) -> ResObj")}, {"SetControlData_Callback", (PyCFunction)CtlObj_SetControlData_Callback, 1, - "(callbackfunc) -> None"}, + PyDoc_STR("(callbackfunc) -> None")}, #if !TARGET_API_MAC_CARBON {"GetPopupData", (PyCFunction)CtlObj_GetPopupData, 1, - NULL}, + PyDoc_STR(NULL)}, #endif #if !TARGET_API_MAC_CARBON {"SetPopupData", (PyCFunction)CtlObj_SetPopupData, 1, - NULL}, + PyDoc_STR(NULL)}, #endif {NULL, NULL, 0} }; @@ -6217,221 +6217,221 @@ static PyObject *Ctl_CreateTabsControl(PyObject *_self, PyObject *_args) static PyMethodDef Ctl_methods[] = { {"NewControl", (PyCFunction)Ctl_NewControl, 1, - "(WindowPtr owningWindow, Rect boundsRect, Str255 controlTitle, Boolean initiallyVisible, SInt16 initialValue, SInt16 minimumValue, SInt16 maximumValue, SInt16 procID, SInt32 controlReference) -> (ControlHandle _rv)"}, + PyDoc_STR("(WindowPtr owningWindow, Rect boundsRect, Str255 controlTitle, Boolean initiallyVisible, SInt16 initialValue, SInt16 minimumValue, SInt16 maximumValue, SInt16 procID, SInt32 controlReference) -> (ControlHandle _rv)")}, {"GetNewControl", (PyCFunction)Ctl_GetNewControl, 1, - "(SInt16 resourceID, WindowPtr owningWindow) -> (ControlHandle _rv)"}, + PyDoc_STR("(SInt16 resourceID, WindowPtr owningWindow) -> (ControlHandle _rv)")}, {"DrawControls", (PyCFunction)Ctl_DrawControls, 1, - "(WindowPtr theWindow) -> None"}, + PyDoc_STR("(WindowPtr theWindow) -> None")}, {"UpdateControls", (PyCFunction)Ctl_UpdateControls, 1, - "(WindowPtr theWindow, RgnHandle updateRegion) -> None"}, + PyDoc_STR("(WindowPtr theWindow, RgnHandle updateRegion) -> None")}, {"FindControl", (PyCFunction)Ctl_FindControl, 1, - "(Point testPoint, WindowPtr theWindow) -> (ControlPartCode _rv, ControlHandle theControl)"}, + PyDoc_STR("(Point testPoint, WindowPtr theWindow) -> (ControlPartCode _rv, ControlHandle theControl)")}, {"IdleControls", (PyCFunction)Ctl_IdleControls, 1, - "(WindowPtr inWindow) -> None"}, + PyDoc_STR("(WindowPtr inWindow) -> None")}, #if TARGET_API_MAC_CARBON {"GetControlByID", (PyCFunction)Ctl_GetControlByID, 1, - "(WindowPtr inWindow, ControlID inID) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr inWindow, ControlID inID) -> (ControlHandle outControl)")}, #endif {"DumpControlHierarchy", (PyCFunction)Ctl_DumpControlHierarchy, 1, - "(WindowPtr inWindow, FSSpec inDumpFile) -> None"}, + PyDoc_STR("(WindowPtr inWindow, FSSpec inDumpFile) -> None")}, {"CreateRootControl", (PyCFunction)Ctl_CreateRootControl, 1, - "(WindowPtr inWindow) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")}, {"GetRootControl", (PyCFunction)Ctl_GetRootControl, 1, - "(WindowPtr inWindow) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")}, {"GetKeyboardFocus", (PyCFunction)Ctl_GetKeyboardFocus, 1, - "(WindowPtr inWindow) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")}, {"SetKeyboardFocus", (PyCFunction)Ctl_SetKeyboardFocus, 1, - "(WindowPtr inWindow, ControlHandle inControl, ControlFocusPart inPart) -> None"}, + PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl, ControlFocusPart inPart) -> None")}, {"AdvanceKeyboardFocus", (PyCFunction)Ctl_AdvanceKeyboardFocus, 1, - "(WindowPtr inWindow) -> None"}, + PyDoc_STR("(WindowPtr inWindow) -> None")}, {"ReverseKeyboardFocus", (PyCFunction)Ctl_ReverseKeyboardFocus, 1, - "(WindowPtr inWindow) -> None"}, + PyDoc_STR("(WindowPtr inWindow) -> None")}, {"ClearKeyboardFocus", (PyCFunction)Ctl_ClearKeyboardFocus, 1, - "(WindowPtr inWindow) -> None"}, + PyDoc_STR("(WindowPtr inWindow) -> None")}, #if TARGET_API_MAC_CARBON {"SetAutomaticControlDragTrackingEnabledForWindow", (PyCFunction)Ctl_SetAutomaticControlDragTrackingEnabledForWindow, 1, - "(WindowPtr theWindow, Boolean tracks) -> None"}, + PyDoc_STR("(WindowPtr theWindow, Boolean tracks) -> None")}, #endif #if TARGET_API_MAC_CARBON {"IsAutomaticControlDragTrackingEnabledForWindow", (PyCFunction)Ctl_IsAutomaticControlDragTrackingEnabledForWindow, 1, - "(WindowPtr theWindow) -> (Boolean tracks)"}, + PyDoc_STR("(WindowPtr theWindow) -> (Boolean tracks)")}, #endif #if TARGET_API_MAC_CARBON {"CreateBevelButtonControl", (PyCFunction)Ctl_CreateBevelButtonControl, 1, - "(WindowPtr window, Rect boundsRect, CFStringRef title, UInt16 thickness, UInt16 behavior, ControlButtonContentInfo info, SInt16 menuID, UInt16 menuBehavior, UInt16 menuPlacement) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, UInt16 thickness, UInt16 behavior, ControlButtonContentInfo info, SInt16 menuID, UInt16 menuBehavior, UInt16 menuPlacement) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateSliderControl", (PyCFunction)Ctl_CreateSliderControl, 1, - "(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, UInt16 orientation, UInt16 numTickMarks, Boolean liveTracking, PyObject* liveTrackingProc) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, UInt16 orientation, UInt16 numTickMarks, Boolean liveTracking, PyObject* liveTrackingProc) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateDisclosureTriangleControl", (PyCFunction)Ctl_CreateDisclosureTriangleControl, 1, - "(WindowPtr window, Rect boundsRect, UInt16 orientation, CFStringRef title, SInt32 initialValue, Boolean drawTitle, Boolean autoToggles) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, UInt16 orientation, CFStringRef title, SInt32 initialValue, Boolean drawTitle, Boolean autoToggles) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateProgressBarControl", (PyCFunction)Ctl_CreateProgressBarControl, 1, - "(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, Boolean indeterminate) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, Boolean indeterminate) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_OSX {"CreateRelevanceBarControl", (PyCFunction)Ctl_CreateRelevanceBarControl, 1, - "(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateLittleArrowsControl", (PyCFunction)Ctl_CreateLittleArrowsControl, 1, - "(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, SInt32 increment) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, SInt32 increment) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateChasingArrowsControl", (PyCFunction)Ctl_CreateChasingArrowsControl, 1, - "(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateSeparatorControl", (PyCFunction)Ctl_CreateSeparatorControl, 1, - "(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateGroupBoxControl", (PyCFunction)Ctl_CreateGroupBoxControl, 1, - "(WindowPtr window, Rect boundsRect, CFStringRef title, Boolean primary) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, Boolean primary) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateCheckGroupBoxControl", (PyCFunction)Ctl_CreateCheckGroupBoxControl, 1, - "(WindowPtr window, Rect boundsRect, CFStringRef title, SInt32 initialValue, Boolean primary, Boolean autoToggle) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, SInt32 initialValue, Boolean primary, Boolean autoToggle) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreatePopupGroupBoxControl", (PyCFunction)Ctl_CreatePopupGroupBoxControl, 1, - "(WindowPtr window, Rect boundsRect, CFStringRef title, Boolean primary, SInt16 menuID, Boolean variableWidth, SInt16 titleWidth, SInt16 titleJustification, Style titleStyle) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, Boolean primary, SInt16 menuID, Boolean variableWidth, SInt16 titleWidth, SInt16 titleJustification, Style titleStyle) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateImageWellControl", (PyCFunction)Ctl_CreateImageWellControl, 1, - "(WindowPtr window, Rect boundsRect, ControlButtonContentInfo info) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, ControlButtonContentInfo info) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreatePopupArrowControl", (PyCFunction)Ctl_CreatePopupArrowControl, 1, - "(WindowPtr window, Rect boundsRect, UInt16 orientation, UInt16 size) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, UInt16 orientation, UInt16 size) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreatePlacardControl", (PyCFunction)Ctl_CreatePlacardControl, 1, - "(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateClockControl", (PyCFunction)Ctl_CreateClockControl, 1, - "(WindowPtr window, Rect boundsRect, UInt16 clockType, UInt32 clockFlags) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, UInt16 clockType, UInt32 clockFlags) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateUserPaneControl", (PyCFunction)Ctl_CreateUserPaneControl, 1, - "(WindowPtr window, Rect boundsRect, UInt32 features) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, UInt32 features) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateEditTextControl", (PyCFunction)Ctl_CreateEditTextControl, 1, - "(WindowPtr window, Rect boundsRect, CFStringRef text, Boolean isPassword, Boolean useInlineInput, ControlFontStyleRec style) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef text, Boolean isPassword, Boolean useInlineInput, ControlFontStyleRec style) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateStaticTextControl", (PyCFunction)Ctl_CreateStaticTextControl, 1, - "(WindowPtr window, Rect boundsRect, CFStringRef text, ControlFontStyleRec style) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef text, ControlFontStyleRec style) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreatePictureControl", (PyCFunction)Ctl_CreatePictureControl, 1, - "(WindowPtr window, Rect boundsRect, ControlButtonContentInfo content, Boolean dontTrack) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, ControlButtonContentInfo content, Boolean dontTrack) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateIconControl", (PyCFunction)Ctl_CreateIconControl, 1, - "(WindowPtr window, Rect boundsRect, ControlButtonContentInfo icon, Boolean dontTrack) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, ControlButtonContentInfo icon, Boolean dontTrack) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateWindowHeaderControl", (PyCFunction)Ctl_CreateWindowHeaderControl, 1, - "(WindowPtr window, Rect boundsRect, Boolean isListHeader) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, Boolean isListHeader) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreatePushButtonControl", (PyCFunction)Ctl_CreatePushButtonControl, 1, - "(WindowPtr window, Rect boundsRect, CFStringRef title) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreatePushButtonWithIconControl", (PyCFunction)Ctl_CreatePushButtonWithIconControl, 1, - "(WindowPtr window, Rect boundsRect, CFStringRef title, ControlButtonContentInfo icon, UInt16 iconAlignment) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, ControlButtonContentInfo icon, UInt16 iconAlignment) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateRadioButtonControl", (PyCFunction)Ctl_CreateRadioButtonControl, 1, - "(WindowPtr window, Rect boundsRect, CFStringRef title, SInt32 initialValue, Boolean autoToggle) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, SInt32 initialValue, Boolean autoToggle) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateCheckBoxControl", (PyCFunction)Ctl_CreateCheckBoxControl, 1, - "(WindowPtr window, Rect boundsRect, CFStringRef title, SInt32 initialValue, Boolean autoToggle) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, SInt32 initialValue, Boolean autoToggle) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateScrollBarControl", (PyCFunction)Ctl_CreateScrollBarControl, 1, - "(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, SInt32 viewSize, Boolean liveTracking, PyObject* liveTrackingProc) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, SInt32 value, SInt32 minimum, SInt32 maximum, SInt32 viewSize, Boolean liveTracking, PyObject* liveTrackingProc) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreatePopupButtonControl", (PyCFunction)Ctl_CreatePopupButtonControl, 1, - "(WindowPtr window, Rect boundsRect, CFStringRef title, SInt16 menuID, Boolean variableWidth, SInt16 titleWidth, SInt16 titleJustification, Style titleStyle) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef title, SInt16 menuID, Boolean variableWidth, SInt16 titleWidth, SInt16 titleJustification, Style titleStyle) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateRadioGroupControl", (PyCFunction)Ctl_CreateRadioGroupControl, 1, - "(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateScrollingTextBoxControl", (PyCFunction)Ctl_CreateScrollingTextBoxControl, 1, - "(WindowPtr window, Rect boundsRect, SInt16 contentResID, Boolean autoScroll, UInt32 delayBeforeAutoScroll, UInt32 delayBetweenAutoScroll, UInt16 autoScrollAmount) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, SInt16 contentResID, Boolean autoScroll, UInt32 delayBeforeAutoScroll, UInt32 delayBetweenAutoScroll, UInt16 autoScrollAmount) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_OSX {"CreateDisclosureButtonControl", (PyCFunction)Ctl_CreateDisclosureButtonControl, 1, - "(WindowPtr inWindow, Rect inBoundsRect, SInt32 inValue, Boolean inAutoToggles) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr inWindow, Rect inBoundsRect, SInt32 inValue, Boolean inAutoToggles) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_OSX {"CreateRoundButtonControl", (PyCFunction)Ctl_CreateRoundButtonControl, 1, - "(WindowPtr inWindow, Rect inBoundsRect, SInt16 inSize, ControlButtonContentInfo inContent) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr inWindow, Rect inBoundsRect, SInt16 inSize, ControlButtonContentInfo inContent) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_CARBON {"CreateDataBrowserControl", (PyCFunction)Ctl_CreateDataBrowserControl, 1, - "(WindowPtr window, Rect boundsRect, OSType style) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, OSType style) -> (ControlHandle outControl)")}, #endif #if TARGET_API_MAC_OSX {"CreateEditUnicodeTextControl", (PyCFunction)Ctl_CreateEditUnicodeTextControl, 1, - "(WindowPtr window, Rect boundsRect, CFStringRef text, Boolean isPassword, ControlFontStyleRec style) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, CFStringRef text, Boolean isPassword, ControlFontStyleRec style) -> (ControlHandle outControl)")}, #endif {"FindControlUnderMouse", (PyCFunction)Ctl_FindControlUnderMouse, 1, - "(Point inWhere, WindowPtr inWindow) -> (ControlHandle _rv, SInt16 outPart)"}, + PyDoc_STR("(Point inWhere, WindowPtr inWindow) -> (ControlHandle _rv, SInt16 outPart)")}, {"as_Control", (PyCFunction)Ctl_as_Control, 1, - "(Handle h) -> (ControlHandle _rv)"}, + PyDoc_STR("(Handle h) -> (ControlHandle _rv)")}, #if TARGET_API_MAC_CARBON {"CreateTabsControl", (PyCFunction)Ctl_CreateTabsControl, 1, - "(WindowPtr window, Rect boundsRect, UInt16 size, UInt16 direction, ControlTabEntry tabArray) -> (ControlHandle outControl)"}, + PyDoc_STR("(WindowPtr window, Rect boundsRect, UInt16 size, UInt16 direction, ControlTabEntry tabArray) -> (ControlHandle outControl)")}, #endif {NULL, NULL, 0} }; diff --git a/Mac/Modules/dlg/_Dlgmodule.c b/Mac/Modules/dlg/_Dlgmodule.c index 4a7e18d..6651622 100644 --- a/Mac/Modules/dlg/_Dlgmodule.c +++ b/Mac/Modules/dlg/_Dlgmodule.c @@ -882,85 +882,85 @@ static PyObject *DlgObj_GetDialogPort(DialogObject *_self, PyObject *_args) static PyMethodDef DlgObj_methods[] = { {"DrawDialog", (PyCFunction)DlgObj_DrawDialog, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"UpdateDialog", (PyCFunction)DlgObj_UpdateDialog, 1, - "(RgnHandle updateRgn) -> None"}, + PyDoc_STR("(RgnHandle updateRgn) -> None")}, {"HideDialogItem", (PyCFunction)DlgObj_HideDialogItem, 1, - "(DialogItemIndex itemNo) -> None"}, + PyDoc_STR("(DialogItemIndex itemNo) -> None")}, {"ShowDialogItem", (PyCFunction)DlgObj_ShowDialogItem, 1, - "(DialogItemIndex itemNo) -> None"}, + PyDoc_STR("(DialogItemIndex itemNo) -> None")}, {"FindDialogItem", (PyCFunction)DlgObj_FindDialogItem, 1, - "(Point thePt) -> (DialogItemIndexZeroBased _rv)"}, + PyDoc_STR("(Point thePt) -> (DialogItemIndexZeroBased _rv)")}, {"DialogCut", (PyCFunction)DlgObj_DialogCut, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"DialogPaste", (PyCFunction)DlgObj_DialogPaste, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"DialogCopy", (PyCFunction)DlgObj_DialogCopy, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"DialogDelete", (PyCFunction)DlgObj_DialogDelete, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"GetDialogItem", (PyCFunction)DlgObj_GetDialogItem, 1, - "(DialogItemIndex itemNo) -> (DialogItemType itemType, Handle item, Rect box)"}, + PyDoc_STR("(DialogItemIndex itemNo) -> (DialogItemType itemType, Handle item, Rect box)")}, {"SetDialogItem", (PyCFunction)DlgObj_SetDialogItem, 1, - "(DialogItemIndex itemNo, DialogItemType itemType, Handle item, Rect box) -> None"}, + PyDoc_STR("(DialogItemIndex itemNo, DialogItemType itemType, Handle item, Rect box) -> None")}, {"SelectDialogItemText", (PyCFunction)DlgObj_SelectDialogItemText, 1, - "(DialogItemIndex itemNo, SInt16 strtSel, SInt16 endSel) -> None"}, + PyDoc_STR("(DialogItemIndex itemNo, SInt16 strtSel, SInt16 endSel) -> None")}, {"AppendDITL", (PyCFunction)DlgObj_AppendDITL, 1, - "(Handle theHandle, DITLMethod method) -> None"}, + PyDoc_STR("(Handle theHandle, DITLMethod method) -> None")}, {"CountDITL", (PyCFunction)DlgObj_CountDITL, 1, - "() -> (DialogItemIndex _rv)"}, + PyDoc_STR("() -> (DialogItemIndex _rv)")}, {"ShortenDITL", (PyCFunction)DlgObj_ShortenDITL, 1, - "(DialogItemIndex numberItems) -> None"}, + PyDoc_STR("(DialogItemIndex numberItems) -> None")}, #if TARGET_API_MAC_CARBON {"InsertDialogItem", (PyCFunction)DlgObj_InsertDialogItem, 1, - "(DialogItemIndex afterItem, DialogItemType itemType, Handle itemHandle, Rect box) -> None"}, + PyDoc_STR("(DialogItemIndex afterItem, DialogItemType itemType, Handle itemHandle, Rect box) -> None")}, #endif #if TARGET_API_MAC_CARBON {"RemoveDialogItems", (PyCFunction)DlgObj_RemoveDialogItems, 1, - "(DialogItemIndex itemNo, DialogItemIndex amountToRemove, Boolean disposeItemData) -> None"}, + PyDoc_STR("(DialogItemIndex itemNo, DialogItemIndex amountToRemove, Boolean disposeItemData) -> None")}, #endif {"StdFilterProc", (PyCFunction)DlgObj_StdFilterProc, 1, - "() -> (Boolean _rv, EventRecord event, DialogItemIndex itemHit)"}, + PyDoc_STR("() -> (Boolean _rv, EventRecord event, DialogItemIndex itemHit)")}, {"SetDialogDefaultItem", (PyCFunction)DlgObj_SetDialogDefaultItem, 1, - "(DialogItemIndex newItem) -> None"}, + PyDoc_STR("(DialogItemIndex newItem) -> None")}, {"SetDialogCancelItem", (PyCFunction)DlgObj_SetDialogCancelItem, 1, - "(DialogItemIndex newItem) -> None"}, + PyDoc_STR("(DialogItemIndex newItem) -> None")}, {"SetDialogTracksCursor", (PyCFunction)DlgObj_SetDialogTracksCursor, 1, - "(Boolean tracks) -> None"}, + PyDoc_STR("(Boolean tracks) -> None")}, {"AutoSizeDialog", (PyCFunction)DlgObj_AutoSizeDialog, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"GetDialogItemAsControl", (PyCFunction)DlgObj_GetDialogItemAsControl, 1, - "(SInt16 inItemNo) -> (ControlHandle outControl)"}, + PyDoc_STR("(SInt16 inItemNo) -> (ControlHandle outControl)")}, {"MoveDialogItem", (PyCFunction)DlgObj_MoveDialogItem, 1, - "(SInt16 inItemNo, SInt16 inHoriz, SInt16 inVert) -> None"}, + PyDoc_STR("(SInt16 inItemNo, SInt16 inHoriz, SInt16 inVert) -> None")}, {"SizeDialogItem", (PyCFunction)DlgObj_SizeDialogItem, 1, - "(SInt16 inItemNo, SInt16 inWidth, SInt16 inHeight) -> None"}, + PyDoc_STR("(SInt16 inItemNo, SInt16 inWidth, SInt16 inHeight) -> None")}, {"AppendDialogItemList", (PyCFunction)DlgObj_AppendDialogItemList, 1, - "(SInt16 ditlID, DITLMethod method) -> None"}, + PyDoc_STR("(SInt16 ditlID, DITLMethod method) -> None")}, {"SetDialogTimeout", (PyCFunction)DlgObj_SetDialogTimeout, 1, - "(SInt16 inButtonToPress, UInt32 inSecondsToWait) -> None"}, + PyDoc_STR("(SInt16 inButtonToPress, UInt32 inSecondsToWait) -> None")}, {"GetDialogTimeout", (PyCFunction)DlgObj_GetDialogTimeout, 1, - "() -> (SInt16 outButtonToPress, UInt32 outSecondsToWait, UInt32 outSecondsRemaining)"}, + PyDoc_STR("() -> (SInt16 outButtonToPress, UInt32 outSecondsToWait, UInt32 outSecondsRemaining)")}, {"SetModalDialogEventMask", (PyCFunction)DlgObj_SetModalDialogEventMask, 1, - "(EventMask inMask) -> None"}, + PyDoc_STR("(EventMask inMask) -> None")}, {"GetModalDialogEventMask", (PyCFunction)DlgObj_GetModalDialogEventMask, 1, - "() -> (EventMask outMask)"}, + PyDoc_STR("() -> (EventMask outMask)")}, {"GetDialogWindow", (PyCFunction)DlgObj_GetDialogWindow, 1, - "() -> (WindowPtr _rv)"}, + PyDoc_STR("() -> (WindowPtr _rv)")}, {"GetDialogTextEditHandle", (PyCFunction)DlgObj_GetDialogTextEditHandle, 1, - "() -> (TEHandle _rv)"}, + PyDoc_STR("() -> (TEHandle _rv)")}, {"GetDialogDefaultItem", (PyCFunction)DlgObj_GetDialogDefaultItem, 1, - "() -> (SInt16 _rv)"}, + PyDoc_STR("() -> (SInt16 _rv)")}, {"GetDialogCancelItem", (PyCFunction)DlgObj_GetDialogCancelItem, 1, - "() -> (SInt16 _rv)"}, + PyDoc_STR("() -> (SInt16 _rv)")}, {"GetDialogKeyboardFocusItem", (PyCFunction)DlgObj_GetDialogKeyboardFocusItem, 1, - "() -> (SInt16 _rv)"}, + PyDoc_STR("() -> (SInt16 _rv)")}, {"SetPortDialogPort", (PyCFunction)DlgObj_SetPortDialogPort, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"GetDialogPort", (PyCFunction)DlgObj_GetDialogPort, 1, - "() -> (CGrafPtr _rv)"}, + PyDoc_STR("() -> (CGrafPtr _rv)")}, {NULL, NULL, 0} }; @@ -1471,48 +1471,48 @@ static PyObject *Dlg_SetUserItemHandler(PyObject *_self, PyObject *_args) static PyMethodDef Dlg_methods[] = { {"NewDialog", (PyCFunction)Dlg_NewDialog, 1, - "(Rect boundsRect, Str255 title, Boolean visible, SInt16 procID, WindowPtr behind, Boolean goAwayFlag, SInt32 refCon, Handle items) -> (DialogPtr _rv)"}, + PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, SInt16 procID, WindowPtr behind, Boolean goAwayFlag, SInt32 refCon, Handle items) -> (DialogPtr _rv)")}, {"GetNewDialog", (PyCFunction)Dlg_GetNewDialog, 1, - "(SInt16 dialogID, WindowPtr behind) -> (DialogPtr _rv)"}, + PyDoc_STR("(SInt16 dialogID, WindowPtr behind) -> (DialogPtr _rv)")}, {"NewColorDialog", (PyCFunction)Dlg_NewColorDialog, 1, - "(Rect boundsRect, Str255 title, Boolean visible, SInt16 procID, WindowPtr behind, Boolean goAwayFlag, SInt32 refCon, Handle items) -> (DialogPtr _rv)"}, + PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, SInt16 procID, WindowPtr behind, Boolean goAwayFlag, SInt32 refCon, Handle items) -> (DialogPtr _rv)")}, {"ModalDialog", (PyCFunction)Dlg_ModalDialog, 1, - "(PyObject* modalFilter) -> (DialogItemIndex itemHit)"}, + PyDoc_STR("(PyObject* modalFilter) -> (DialogItemIndex itemHit)")}, {"IsDialogEvent", (PyCFunction)Dlg_IsDialogEvent, 1, - "(EventRecord theEvent) -> (Boolean _rv)"}, + PyDoc_STR("(EventRecord theEvent) -> (Boolean _rv)")}, {"DialogSelect", (PyCFunction)Dlg_DialogSelect, 1, - "(EventRecord theEvent) -> (Boolean _rv, DialogPtr theDialog, DialogItemIndex itemHit)"}, + PyDoc_STR("(EventRecord theEvent) -> (Boolean _rv, DialogPtr theDialog, DialogItemIndex itemHit)")}, {"Alert", (PyCFunction)Dlg_Alert, 1, - "(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"}, + PyDoc_STR("(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)")}, {"StopAlert", (PyCFunction)Dlg_StopAlert, 1, - "(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"}, + PyDoc_STR("(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)")}, {"NoteAlert", (PyCFunction)Dlg_NoteAlert, 1, - "(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"}, + PyDoc_STR("(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)")}, {"CautionAlert", (PyCFunction)Dlg_CautionAlert, 1, - "(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"}, + PyDoc_STR("(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)")}, {"ParamText", (PyCFunction)Dlg_ParamText, 1, - "(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None"}, + PyDoc_STR("(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None")}, {"GetDialogItemText", (PyCFunction)Dlg_GetDialogItemText, 1, - "(Handle item) -> (Str255 text)"}, + PyDoc_STR("(Handle item) -> (Str255 text)")}, {"SetDialogItemText", (PyCFunction)Dlg_SetDialogItemText, 1, - "(Handle item, Str255 text) -> None"}, + PyDoc_STR("(Handle item, Str255 text) -> None")}, {"GetAlertStage", (PyCFunction)Dlg_GetAlertStage, 1, - "() -> (SInt16 _rv)"}, + PyDoc_STR("() -> (SInt16 _rv)")}, {"SetDialogFont", (PyCFunction)Dlg_SetDialogFont, 1, - "(SInt16 fontNum) -> None"}, + PyDoc_STR("(SInt16 fontNum) -> None")}, {"ResetAlertStage", (PyCFunction)Dlg_ResetAlertStage, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #if TARGET_API_MAC_CARBON {"GetParamText", (PyCFunction)Dlg_GetParamText, 1, - "(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None"}, + PyDoc_STR("(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None")}, #endif {"NewFeaturesDialog", (PyCFunction)Dlg_NewFeaturesDialog, 1, - "(Rect inBoundsRect, Str255 inTitle, Boolean inIsVisible, SInt16 inProcID, WindowPtr inBehind, Boolean inGoAwayFlag, SInt32 inRefCon, Handle inItemListHandle, UInt32 inFlags) -> (DialogPtr _rv)"}, + PyDoc_STR("(Rect inBoundsRect, Str255 inTitle, Boolean inIsVisible, SInt16 inProcID, WindowPtr inBehind, Boolean inGoAwayFlag, SInt32 inRefCon, Handle inItemListHandle, UInt32 inFlags) -> (DialogPtr _rv)")}, {"GetDialogFromWindow", (PyCFunction)Dlg_GetDialogFromWindow, 1, - "(WindowPtr window) -> (DialogPtr _rv)"}, + PyDoc_STR("(WindowPtr window) -> (DialogPtr _rv)")}, {"SetUserItemHandler", (PyCFunction)Dlg_SetUserItemHandler, 1, - NULL}, + PyDoc_STR(NULL)}, {NULL, NULL, 0} }; diff --git a/Mac/Modules/drag/_Dragmodule.c b/Mac/Modules/drag/_Dragmodule.c index 357d7dc..1e1dc8b 100644 --- a/Mac/Modules/drag/_Dragmodule.c +++ b/Mac/Modules/drag/_Dragmodule.c @@ -684,59 +684,59 @@ static PyObject *DragObj_UpdateDragHilite(DragObjObject *_self, PyObject *_args) static PyMethodDef DragObj_methods[] = { {"DisposeDrag", (PyCFunction)DragObj_DisposeDrag, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"AddDragItemFlavor", (PyCFunction)DragObj_AddDragItemFlavor, 1, - "(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, FlavorFlags theFlags) -> None"}, + PyDoc_STR("(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, FlavorFlags theFlags) -> None")}, {"SetDragItemFlavorData", (PyCFunction)DragObj_SetDragItemFlavorData, 1, - "(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, UInt32 dataOffset) -> None"}, + PyDoc_STR("(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, UInt32 dataOffset) -> None")}, {"SetDragImage", (PyCFunction)DragObj_SetDragImage, 1, - "(PixMapHandle imagePixMap, RgnHandle imageRgn, Point imageOffsetPt, DragImageFlags theImageFlags) -> None"}, + PyDoc_STR("(PixMapHandle imagePixMap, RgnHandle imageRgn, Point imageOffsetPt, DragImageFlags theImageFlags) -> None")}, {"ChangeDragBehaviors", (PyCFunction)DragObj_ChangeDragBehaviors, 1, - "(DragBehaviors inBehaviorsToSet, DragBehaviors inBehaviorsToClear) -> None"}, + PyDoc_STR("(DragBehaviors inBehaviorsToSet, DragBehaviors inBehaviorsToClear) -> None")}, {"TrackDrag", (PyCFunction)DragObj_TrackDrag, 1, - "(EventRecord theEvent, RgnHandle theRegion) -> None"}, + PyDoc_STR("(EventRecord theEvent, RgnHandle theRegion) -> None")}, {"CountDragItems", (PyCFunction)DragObj_CountDragItems, 1, - "() -> (UInt16 numItems)"}, + PyDoc_STR("() -> (UInt16 numItems)")}, {"GetDragItemReferenceNumber", (PyCFunction)DragObj_GetDragItemReferenceNumber, 1, - "(UInt16 index) -> (ItemReference theItemRef)"}, + PyDoc_STR("(UInt16 index) -> (ItemReference theItemRef)")}, {"CountDragItemFlavors", (PyCFunction)DragObj_CountDragItemFlavors, 1, - "(ItemReference theItemRef) -> (UInt16 numFlavors)"}, + PyDoc_STR("(ItemReference theItemRef) -> (UInt16 numFlavors)")}, {"GetFlavorType", (PyCFunction)DragObj_GetFlavorType, 1, - "(ItemReference theItemRef, UInt16 index) -> (FlavorType theType)"}, + PyDoc_STR("(ItemReference theItemRef, UInt16 index) -> (FlavorType theType)")}, {"GetFlavorFlags", (PyCFunction)DragObj_GetFlavorFlags, 1, - "(ItemReference theItemRef, FlavorType theType) -> (FlavorFlags theFlags)"}, + PyDoc_STR("(ItemReference theItemRef, FlavorType theType) -> (FlavorFlags theFlags)")}, {"GetFlavorDataSize", (PyCFunction)DragObj_GetFlavorDataSize, 1, - "(ItemReference theItemRef, FlavorType theType) -> (Size dataSize)"}, + PyDoc_STR("(ItemReference theItemRef, FlavorType theType) -> (Size dataSize)")}, {"GetFlavorData", (PyCFunction)DragObj_GetFlavorData, 1, - "(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, UInt32 dataOffset) -> (Buffer dataPtr)"}, + PyDoc_STR("(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, UInt32 dataOffset) -> (Buffer dataPtr)")}, {"GetDragItemBounds", (PyCFunction)DragObj_GetDragItemBounds, 1, - "(ItemReference theItemRef) -> (Rect itemBounds)"}, + PyDoc_STR("(ItemReference theItemRef) -> (Rect itemBounds)")}, {"SetDragItemBounds", (PyCFunction)DragObj_SetDragItemBounds, 1, - "(ItemReference theItemRef, Rect itemBounds) -> None"}, + PyDoc_STR("(ItemReference theItemRef, Rect itemBounds) -> None")}, {"GetDropLocation", (PyCFunction)DragObj_GetDropLocation, 1, - "() -> (AEDesc dropLocation)"}, + PyDoc_STR("() -> (AEDesc dropLocation)")}, {"SetDropLocation", (PyCFunction)DragObj_SetDropLocation, 1, - "(AEDesc dropLocation) -> None"}, + PyDoc_STR("(AEDesc dropLocation) -> None")}, {"GetDragAttributes", (PyCFunction)DragObj_GetDragAttributes, 1, - "() -> (DragAttributes flags)"}, + PyDoc_STR("() -> (DragAttributes flags)")}, {"GetDragMouse", (PyCFunction)DragObj_GetDragMouse, 1, - "() -> (Point mouse, Point globalPinnedMouse)"}, + PyDoc_STR("() -> (Point mouse, Point globalPinnedMouse)")}, {"SetDragMouse", (PyCFunction)DragObj_SetDragMouse, 1, - "(Point globalPinnedMouse) -> None"}, + PyDoc_STR("(Point globalPinnedMouse) -> None")}, {"GetDragOrigin", (PyCFunction)DragObj_GetDragOrigin, 1, - "() -> (Point globalInitialMouse)"}, + PyDoc_STR("() -> (Point globalInitialMouse)")}, {"GetDragModifiers", (PyCFunction)DragObj_GetDragModifiers, 1, - "() -> (SInt16 modifiers, SInt16 mouseDownModifiers, SInt16 mouseUpModifiers)"}, + PyDoc_STR("() -> (SInt16 modifiers, SInt16 mouseDownModifiers, SInt16 mouseUpModifiers)")}, {"ShowDragHilite", (PyCFunction)DragObj_ShowDragHilite, 1, - "(RgnHandle hiliteFrame, Boolean inside) -> None"}, + PyDoc_STR("(RgnHandle hiliteFrame, Boolean inside) -> None")}, {"HideDragHilite", (PyCFunction)DragObj_HideDragHilite, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"DragPreScroll", (PyCFunction)DragObj_DragPreScroll, 1, - "(SInt16 dH, SInt16 dV) -> None"}, + PyDoc_STR("(SInt16 dH, SInt16 dV) -> None")}, {"DragPostScroll", (PyCFunction)DragObj_DragPostScroll, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"UpdateDragHilite", (PyCFunction)DragObj_UpdateDragHilite, 1, - "(RgnHandle updateRgn) -> None"}, + PyDoc_STR("(RgnHandle updateRgn) -> None")}, {NULL, NULL, 0} }; @@ -959,23 +959,23 @@ static PyObject *Drag_RemoveReceiveHandler(PyObject *_self, PyObject *_args) static PyMethodDef Drag_methods[] = { {"NewDrag", (PyCFunction)Drag_NewDrag, 1, - "() -> (DragRef theDrag)"}, + PyDoc_STR("() -> (DragRef theDrag)")}, {"GetDragHiliteColor", (PyCFunction)Drag_GetDragHiliteColor, 1, - "(WindowPtr window) -> (RGBColor color)"}, + PyDoc_STR("(WindowPtr window) -> (RGBColor color)")}, {"WaitMouseMoved", (PyCFunction)Drag_WaitMouseMoved, 1, - "(Point initialMouse) -> (Boolean _rv)"}, + PyDoc_STR("(Point initialMouse) -> (Boolean _rv)")}, {"ZoomRects", (PyCFunction)Drag_ZoomRects, 1, - "(Rect fromRect, Rect toRect, SInt16 zoomSteps, ZoomAcceleration acceleration) -> None"}, + PyDoc_STR("(Rect fromRect, Rect toRect, SInt16 zoomSteps, ZoomAcceleration acceleration) -> None")}, {"ZoomRegion", (PyCFunction)Drag_ZoomRegion, 1, - "(RgnHandle region, Point zoomDistance, SInt16 zoomSteps, ZoomAcceleration acceleration) -> None"}, + PyDoc_STR("(RgnHandle region, Point zoomDistance, SInt16 zoomSteps, ZoomAcceleration acceleration) -> None")}, {"InstallTrackingHandler", (PyCFunction)Drag_InstallTrackingHandler, 1, - NULL}, + PyDoc_STR(NULL)}, {"InstallReceiveHandler", (PyCFunction)Drag_InstallReceiveHandler, 1, - NULL}, + PyDoc_STR(NULL)}, {"RemoveTrackingHandler", (PyCFunction)Drag_RemoveTrackingHandler, 1, - NULL}, + PyDoc_STR(NULL)}, {"RemoveReceiveHandler", (PyCFunction)Drag_RemoveReceiveHandler, 1, - NULL}, + PyDoc_STR(NULL)}, {NULL, NULL, 0} }; diff --git a/Mac/Modules/evt/_Evtmodule.c b/Mac/Modules/evt/_Evtmodule.c index df098fa..ff75403 100644 --- a/Mac/Modules/evt/_Evtmodule.c +++ b/Mac/Modules/evt/_Evtmodule.c @@ -592,93 +592,93 @@ static PyObject *Evt_WaitNextEvent(PyObject *_self, PyObject *_args) static PyMethodDef Evt_methods[] = { {"GetMouse", (PyCFunction)Evt_GetMouse, 1, - "() -> (Point mouseLoc)"}, + PyDoc_STR("() -> (Point mouseLoc)")}, {"Button", (PyCFunction)Evt_Button, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, {"StillDown", (PyCFunction)Evt_StillDown, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, {"WaitMouseUp", (PyCFunction)Evt_WaitMouseUp, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, {"GetCaretTime", (PyCFunction)Evt_GetCaretTime, 1, - "() -> (UInt32 _rv)"}, + PyDoc_STR("() -> (UInt32 _rv)")}, {"GetKeys", (PyCFunction)Evt_GetKeys, 1, - "() -> (KeyMap theKeys)"}, + PyDoc_STR("() -> (KeyMap theKeys)")}, {"GetDblTime", (PyCFunction)Evt_GetDblTime, 1, - "() -> (UInt32 _rv)"}, + PyDoc_STR("() -> (UInt32 _rv)")}, {"SetEventMask", (PyCFunction)Evt_SetEventMask, 1, - "(EventMask value) -> None"}, + PyDoc_STR("(EventMask value) -> None")}, {"GetNextEvent", (PyCFunction)Evt_GetNextEvent, 1, - "(EventMask eventMask) -> (Boolean _rv, EventRecord theEvent)"}, + PyDoc_STR("(EventMask eventMask) -> (Boolean _rv, EventRecord theEvent)")}, {"EventAvail", (PyCFunction)Evt_EventAvail, 1, - "(EventMask eventMask) -> (Boolean _rv, EventRecord theEvent)"}, + PyDoc_STR("(EventMask eventMask) -> (Boolean _rv, EventRecord theEvent)")}, {"PostEvent", (PyCFunction)Evt_PostEvent, 1, - "(EventKind eventNum, UInt32 eventMsg) -> None"}, + PyDoc_STR("(EventKind eventNum, UInt32 eventMsg) -> None")}, #if !TARGET_API_MAC_CARBON {"OSEventAvail", (PyCFunction)Evt_OSEventAvail, 1, - "(EventMask mask) -> (Boolean _rv, EventRecord theEvent)"}, + PyDoc_STR("(EventMask mask) -> (Boolean _rv, EventRecord theEvent)")}, #endif #if !TARGET_API_MAC_CARBON {"GetOSEvent", (PyCFunction)Evt_GetOSEvent, 1, - "(EventMask mask) -> (Boolean _rv, EventRecord theEvent)"}, + PyDoc_STR("(EventMask mask) -> (Boolean _rv, EventRecord theEvent)")}, #endif {"FlushEvents", (PyCFunction)Evt_FlushEvents, 1, - "(EventMask whichMask, EventMask stopMask) -> None"}, + PyDoc_STR("(EventMask whichMask, EventMask stopMask) -> None")}, #if !TARGET_API_MAC_CARBON {"SystemClick", (PyCFunction)Evt_SystemClick, 1, - "(EventRecord theEvent, WindowPtr theWindow) -> None"}, + PyDoc_STR("(EventRecord theEvent, WindowPtr theWindow) -> None")}, #endif #if !TARGET_API_MAC_CARBON {"SystemTask", (PyCFunction)Evt_SystemTask, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if !TARGET_API_MAC_CARBON {"SystemEvent", (PyCFunction)Evt_SystemEvent, 1, - "(EventRecord theEvent) -> (Boolean _rv)"}, + PyDoc_STR("(EventRecord theEvent) -> (Boolean _rv)")}, #endif #if TARGET_API_MAC_CARBON {"GetGlobalMouse", (PyCFunction)Evt_GetGlobalMouse, 1, - "() -> (Point globalMouse)"}, + PyDoc_STR("() -> (Point globalMouse)")}, #endif #if TARGET_API_MAC_CARBON {"GetCurrentKeyModifiers", (PyCFunction)Evt_GetCurrentKeyModifiers, 1, - "() -> (UInt32 _rv)"}, + PyDoc_STR("() -> (UInt32 _rv)")}, #endif #if TARGET_API_MAC_CARBON {"CheckEventQueueForUserCancel", (PyCFunction)Evt_CheckEventQueueForUserCancel, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, #endif {"KeyScript", (PyCFunction)Evt_KeyScript, 1, - "(short code) -> None"}, + PyDoc_STR("(short code) -> None")}, {"IsCmdChar", (PyCFunction)Evt_IsCmdChar, 1, - "(EventRecord event, short test) -> (Boolean _rv)"}, + PyDoc_STR("(EventRecord event, short test) -> (Boolean _rv)")}, {"LMGetKeyThresh", (PyCFunction)Evt_LMGetKeyThresh, 1, - "() -> (SInt16 _rv)"}, + PyDoc_STR("() -> (SInt16 _rv)")}, {"LMSetKeyThresh", (PyCFunction)Evt_LMSetKeyThresh, 1, - "(SInt16 value) -> None"}, + PyDoc_STR("(SInt16 value) -> None")}, {"LMGetKeyRepThresh", (PyCFunction)Evt_LMGetKeyRepThresh, 1, - "() -> (SInt16 _rv)"}, + PyDoc_STR("() -> (SInt16 _rv)")}, {"LMSetKeyRepThresh", (PyCFunction)Evt_LMSetKeyRepThresh, 1, - "(SInt16 value) -> None"}, + PyDoc_STR("(SInt16 value) -> None")}, {"LMGetKbdLast", (PyCFunction)Evt_LMGetKbdLast, 1, - "() -> (UInt8 _rv)"}, + PyDoc_STR("() -> (UInt8 _rv)")}, {"LMSetKbdLast", (PyCFunction)Evt_LMSetKbdLast, 1, - "(UInt8 value) -> None"}, + PyDoc_STR("(UInt8 value) -> None")}, {"LMGetKbdType", (PyCFunction)Evt_LMGetKbdType, 1, - "() -> (UInt8 _rv)"}, + PyDoc_STR("() -> (UInt8 _rv)")}, {"LMSetKbdType", (PyCFunction)Evt_LMSetKbdType, 1, - "(UInt8 value) -> None"}, + PyDoc_STR("(UInt8 value) -> None")}, {"TickCount", (PyCFunction)Evt_TickCount, 1, - "() -> (UInt32 _rv)"}, + PyDoc_STR("() -> (UInt32 _rv)")}, {"WaitNextEvent", (PyCFunction)Evt_WaitNextEvent, 1, - "(EventMask eventMask, UInt32 sleep [,RegionHandle]) -> (Boolean _rv, EventRecord theEvent)"}, + PyDoc_STR("(EventMask eventMask, UInt32 sleep [,RegionHandle]) -> (Boolean _rv, EventRecord theEvent)")}, {NULL, NULL, 0} }; diff --git a/Mac/Modules/fm/_Fmmodule.c b/Mac/Modules/fm/_Fmmodule.c index e6497f2..245dcb0 100644 --- a/Mac/Modules/fm/_Fmmodule.c +++ b/Mac/Modules/fm/_Fmmodule.c @@ -369,48 +369,48 @@ static PyMethodDef Fm_methods[] = { #if !TARGET_API_MAC_CARBON {"InitFonts", (PyCFunction)Fm_InitFonts, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif {"GetFontName", (PyCFunction)Fm_GetFontName, 1, - "(short familyID) -> (Str255 name)"}, + PyDoc_STR("(short familyID) -> (Str255 name)")}, {"GetFNum", (PyCFunction)Fm_GetFNum, 1, - "(Str255 name) -> (short familyID)"}, + PyDoc_STR("(Str255 name) -> (short familyID)")}, {"RealFont", (PyCFunction)Fm_RealFont, 1, - "(short fontNum, short size) -> (Boolean _rv)"}, + PyDoc_STR("(short fontNum, short size) -> (Boolean _rv)")}, #if !TARGET_API_MAC_CARBON {"SetFontLock", (PyCFunction)Fm_SetFontLock, 1, - "(Boolean lockFlag) -> None"}, + PyDoc_STR("(Boolean lockFlag) -> None")}, #endif {"SetFScaleDisable", (PyCFunction)Fm_SetFScaleDisable, 1, - "(Boolean fscaleDisable) -> None"}, + PyDoc_STR("(Boolean fscaleDisable) -> None")}, {"FontMetrics", (PyCFunction)Fm_FontMetrics, 1, - "() -> (FMetricRec theMetrics)"}, + PyDoc_STR("() -> (FMetricRec theMetrics)")}, {"SetFractEnable", (PyCFunction)Fm_SetFractEnable, 1, - "(Boolean fractEnable) -> None"}, + PyDoc_STR("(Boolean fractEnable) -> None")}, {"GetDefFontSize", (PyCFunction)Fm_GetDefFontSize, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, {"IsOutline", (PyCFunction)Fm_IsOutline, 1, - "(Point numer, Point denom) -> (Boolean _rv)"}, + PyDoc_STR("(Point numer, Point denom) -> (Boolean _rv)")}, {"SetOutlinePreferred", (PyCFunction)Fm_SetOutlinePreferred, 1, - "(Boolean outlinePreferred) -> None"}, + PyDoc_STR("(Boolean outlinePreferred) -> None")}, {"GetOutlinePreferred", (PyCFunction)Fm_GetOutlinePreferred, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, {"SetPreserveGlyph", (PyCFunction)Fm_SetPreserveGlyph, 1, - "(Boolean preserveGlyph) -> None"}, + PyDoc_STR("(Boolean preserveGlyph) -> None")}, {"GetPreserveGlyph", (PyCFunction)Fm_GetPreserveGlyph, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, #if !TARGET_API_MAC_CARBON {"FlushFonts", (PyCFunction)Fm_FlushFonts, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif {"GetSysFont", (PyCFunction)Fm_GetSysFont, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, {"GetAppFont", (PyCFunction)Fm_GetAppFont, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, {"QDTextBounds", (PyCFunction)Fm_QDTextBounds, 1, - "(Buffer inText) -> (Rect bounds)"}, + PyDoc_STR("(Buffer inText) -> (Rect bounds)")}, {NULL, NULL, 0} }; diff --git a/Mac/Modules/help/_Helpmodule.c b/Mac/Modules/help/_Helpmodule.c index 46f1a35..66cd7b5 100644 --- a/Mac/Modules/help/_Helpmodule.c +++ b/Mac/Modules/help/_Helpmodule.c @@ -249,35 +249,35 @@ static PyObject *Help_HMGetBalloonWindow(PyObject *_self, PyObject *_args) static PyMethodDef Help_methods[] = { {"HMGetHelpMenuHandle", (PyCFunction)Help_HMGetHelpMenuHandle, 1, - "() -> (MenuRef mh)"}, + PyDoc_STR("() -> (MenuRef mh)")}, {"HMRemoveBalloon", (PyCFunction)Help_HMRemoveBalloon, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"HMIsBalloon", (PyCFunction)Help_HMIsBalloon, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, {"HMGetBalloons", (PyCFunction)Help_HMGetBalloons, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, {"HMSetBalloons", (PyCFunction)Help_HMSetBalloons, 1, - "(Boolean flag) -> None"}, + PyDoc_STR("(Boolean flag) -> None")}, {"HMSetFont", (PyCFunction)Help_HMSetFont, 1, - "(SInt16 font) -> None"}, + PyDoc_STR("(SInt16 font) -> None")}, {"HMSetFontSize", (PyCFunction)Help_HMSetFontSize, 1, - "(UInt16 fontSize) -> None"}, + PyDoc_STR("(UInt16 fontSize) -> None")}, {"HMGetFont", (PyCFunction)Help_HMGetFont, 1, - "() -> (SInt16 font)"}, + PyDoc_STR("() -> (SInt16 font)")}, {"HMGetFontSize", (PyCFunction)Help_HMGetFontSize, 1, - "() -> (UInt16 fontSize)"}, + PyDoc_STR("() -> (UInt16 fontSize)")}, {"HMSetDialogResID", (PyCFunction)Help_HMSetDialogResID, 1, - "(SInt16 resID) -> None"}, + PyDoc_STR("(SInt16 resID) -> None")}, {"HMSetMenuResID", (PyCFunction)Help_HMSetMenuResID, 1, - "(SInt16 menuID, SInt16 resID) -> None"}, + PyDoc_STR("(SInt16 menuID, SInt16 resID) -> None")}, {"HMScanTemplateItems", (PyCFunction)Help_HMScanTemplateItems, 1, - "(SInt16 whichID, SInt16 whichResFile, ResType whichType) -> None"}, + PyDoc_STR("(SInt16 whichID, SInt16 whichResFile, ResType whichType) -> None")}, {"HMGetDialogResID", (PyCFunction)Help_HMGetDialogResID, 1, - "() -> (SInt16 resID)"}, + PyDoc_STR("() -> (SInt16 resID)")}, {"HMGetMenuResID", (PyCFunction)Help_HMGetMenuResID, 1, - "(SInt16 menuID) -> (SInt16 resID)"}, + PyDoc_STR("(SInt16 menuID) -> (SInt16 resID)")}, {"HMGetBalloonWindow", (PyCFunction)Help_HMGetBalloonWindow, 1, - "() -> (WindowPtr window)"}, + PyDoc_STR("() -> (WindowPtr window)")}, {NULL, NULL, 0} }; diff --git a/Mac/Modules/ibcarbon/_IBCarbon.c b/Mac/Modules/ibcarbon/_IBCarbon.c index e4cd041..fdddd84 100644 --- a/Mac/Modules/ibcarbon/_IBCarbon.c +++ b/Mac/Modules/ibcarbon/_IBCarbon.c @@ -130,13 +130,13 @@ static PyObject *IBNibRefObj_SetMenuBarFromNib(IBNibRefObject *_self, PyObject * static PyMethodDef IBNibRefObj_methods[] = { {"CreateWindowFromNib", (PyCFunction)IBNibRefObj_CreateWindowFromNib, 1, - "(CFStringRef inName) -> (WindowPtr outWindow)"}, + PyDoc_STR("(CFStringRef inName) -> (WindowPtr outWindow)")}, {"CreateMenuFromNib", (PyCFunction)IBNibRefObj_CreateMenuFromNib, 1, - "(CFStringRef inName) -> (MenuHandle outMenuRef)"}, + PyDoc_STR("(CFStringRef inName) -> (MenuHandle outMenuRef)")}, {"CreateMenuBarFromNib", (PyCFunction)IBNibRefObj_CreateMenuBarFromNib, 1, - "(CFStringRef inName) -> (Handle outMenuBar)"}, + PyDoc_STR("(CFStringRef inName) -> (Handle outMenuBar)")}, {"SetMenuBarFromNib", (PyCFunction)IBNibRefObj_SetMenuBarFromNib, 1, - "(CFStringRef inName) -> None"}, + PyDoc_STR("(CFStringRef inName) -> None")}, {NULL, NULL, 0} }; @@ -196,7 +196,7 @@ static PyObject *IBCarbon_CreateNibReference(PyObject *_self, PyObject *_args) static PyMethodDef IBCarbon_methods[] = { {"CreateNibReference", (PyCFunction)IBCarbon_CreateNibReference, 1, - "(CFStringRef inNibName) -> (IBNibRef outNibRef)"}, + PyDoc_STR("(CFStringRef inNibName) -> (IBNibRef outNibRef)")}, {NULL, NULL, 0} }; diff --git a/Mac/Modules/icn/_Icnmodule.c b/Mac/Modules/icn/_Icnmodule.c index 19930df..93b96ac 100644 --- a/Mac/Modules/icn/_Icnmodule.c +++ b/Mac/Modules/icn/_Icnmodule.c @@ -1442,141 +1442,141 @@ static PyObject *Icn_WriteIconFile(PyObject *_self, PyObject *_args) static PyMethodDef Icn_methods[] = { {"GetCIcon", (PyCFunction)Icn_GetCIcon, 1, - "(SInt16 iconID) -> (CIconHandle _rv)"}, + PyDoc_STR("(SInt16 iconID) -> (CIconHandle _rv)")}, {"PlotCIcon", (PyCFunction)Icn_PlotCIcon, 1, - "(Rect theRect, CIconHandle theIcon) -> None"}, + PyDoc_STR("(Rect theRect, CIconHandle theIcon) -> None")}, {"DisposeCIcon", (PyCFunction)Icn_DisposeCIcon, 1, - "(CIconHandle theIcon) -> None"}, + PyDoc_STR("(CIconHandle theIcon) -> None")}, {"GetIcon", (PyCFunction)Icn_GetIcon, 1, - "(SInt16 iconID) -> (Handle _rv)"}, + PyDoc_STR("(SInt16 iconID) -> (Handle _rv)")}, {"PlotIcon", (PyCFunction)Icn_PlotIcon, 1, - "(Rect theRect, Handle theIcon) -> None"}, + PyDoc_STR("(Rect theRect, Handle theIcon) -> None")}, {"PlotIconID", (PyCFunction)Icn_PlotIconID, 1, - "(Rect theRect, IconAlignmentType align, IconTransformType transform, SInt16 theResID) -> None"}, + PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, SInt16 theResID) -> None")}, {"NewIconSuite", (PyCFunction)Icn_NewIconSuite, 1, - "() -> (IconSuiteRef theIconSuite)"}, + PyDoc_STR("() -> (IconSuiteRef theIconSuite)")}, {"AddIconToSuite", (PyCFunction)Icn_AddIconToSuite, 1, - "(Handle theIconData, IconSuiteRef theSuite, ResType theType) -> None"}, + PyDoc_STR("(Handle theIconData, IconSuiteRef theSuite, ResType theType) -> None")}, {"GetIconFromSuite", (PyCFunction)Icn_GetIconFromSuite, 1, - "(IconSuiteRef theSuite, ResType theType) -> (Handle theIconData)"}, + PyDoc_STR("(IconSuiteRef theSuite, ResType theType) -> (Handle theIconData)")}, {"GetIconSuite", (PyCFunction)Icn_GetIconSuite, 1, - "(SInt16 theResID, IconSelectorValue selector) -> (IconSuiteRef theIconSuite)"}, + PyDoc_STR("(SInt16 theResID, IconSelectorValue selector) -> (IconSuiteRef theIconSuite)")}, {"DisposeIconSuite", (PyCFunction)Icn_DisposeIconSuite, 1, - "(IconSuiteRef theIconSuite, Boolean disposeData) -> None"}, + PyDoc_STR("(IconSuiteRef theIconSuite, Boolean disposeData) -> None")}, {"PlotIconSuite", (PyCFunction)Icn_PlotIconSuite, 1, - "(Rect theRect, IconAlignmentType align, IconTransformType transform, IconSuiteRef theIconSuite) -> None"}, + PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, IconSuiteRef theIconSuite) -> None")}, {"LoadIconCache", (PyCFunction)Icn_LoadIconCache, 1, - "(Rect theRect, IconAlignmentType align, IconTransformType transform, IconCacheRef theIconCache) -> None"}, + PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, IconCacheRef theIconCache) -> None")}, {"GetLabel", (PyCFunction)Icn_GetLabel, 1, - "(SInt16 labelNumber, Str255 labelString) -> (RGBColor labelColor)"}, + PyDoc_STR("(SInt16 labelNumber, Str255 labelString) -> (RGBColor labelColor)")}, {"PtInIconID", (PyCFunction)Icn_PtInIconID, 1, - "(Point testPt, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> (Boolean _rv)"}, + PyDoc_STR("(Point testPt, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> (Boolean _rv)")}, {"PtInIconSuite", (PyCFunction)Icn_PtInIconSuite, 1, - "(Point testPt, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> (Boolean _rv)"}, + PyDoc_STR("(Point testPt, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> (Boolean _rv)")}, {"RectInIconID", (PyCFunction)Icn_RectInIconID, 1, - "(Rect testRect, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> (Boolean _rv)"}, + PyDoc_STR("(Rect testRect, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> (Boolean _rv)")}, {"RectInIconSuite", (PyCFunction)Icn_RectInIconSuite, 1, - "(Rect testRect, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> (Boolean _rv)"}, + PyDoc_STR("(Rect testRect, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> (Boolean _rv)")}, {"IconIDToRgn", (PyCFunction)Icn_IconIDToRgn, 1, - "(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> None"}, + PyDoc_STR("(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> None")}, {"IconSuiteToRgn", (PyCFunction)Icn_IconSuiteToRgn, 1, - "(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> None"}, + PyDoc_STR("(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> None")}, {"SetSuiteLabel", (PyCFunction)Icn_SetSuiteLabel, 1, - "(IconSuiteRef theSuite, SInt16 theLabel) -> None"}, + PyDoc_STR("(IconSuiteRef theSuite, SInt16 theLabel) -> None")}, {"GetSuiteLabel", (PyCFunction)Icn_GetSuiteLabel, 1, - "(IconSuiteRef theSuite) -> (SInt16 _rv)"}, + PyDoc_STR("(IconSuiteRef theSuite) -> (SInt16 _rv)")}, {"PlotIconHandle", (PyCFunction)Icn_PlotIconHandle, 1, - "(Rect theRect, IconAlignmentType align, IconTransformType transform, Handle theIcon) -> None"}, + PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, Handle theIcon) -> None")}, {"PlotSICNHandle", (PyCFunction)Icn_PlotSICNHandle, 1, - "(Rect theRect, IconAlignmentType align, IconTransformType transform, Handle theSICN) -> None"}, + PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, Handle theSICN) -> None")}, {"PlotCIconHandle", (PyCFunction)Icn_PlotCIconHandle, 1, - "(Rect theRect, IconAlignmentType align, IconTransformType transform, CIconHandle theCIcon) -> None"}, + PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, CIconHandle theCIcon) -> None")}, #if !TARGET_API_MAC_CARBON {"IconServicesTerminate", (PyCFunction)Icn_IconServicesTerminate, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif {"IconRefToIconFamily", (PyCFunction)Icn_IconRefToIconFamily, 1, - "(IconRef theIconRef, IconSelectorValue whichIcons) -> (IconFamilyHandle iconFamily)"}, + PyDoc_STR("(IconRef theIconRef, IconSelectorValue whichIcons) -> (IconFamilyHandle iconFamily)")}, {"IconFamilyToIconSuite", (PyCFunction)Icn_IconFamilyToIconSuite, 1, - "(IconFamilyHandle iconFamily, IconSelectorValue whichIcons) -> (IconSuiteRef iconSuite)"}, + PyDoc_STR("(IconFamilyHandle iconFamily, IconSelectorValue whichIcons) -> (IconSuiteRef iconSuite)")}, {"IconSuiteToIconFamily", (PyCFunction)Icn_IconSuiteToIconFamily, 1, - "(IconSuiteRef iconSuite, IconSelectorValue whichIcons) -> (IconFamilyHandle iconFamily)"}, + PyDoc_STR("(IconSuiteRef iconSuite, IconSelectorValue whichIcons) -> (IconFamilyHandle iconFamily)")}, {"SetIconFamilyData", (PyCFunction)Icn_SetIconFamilyData, 1, - "(IconFamilyHandle iconFamily, OSType iconType, Handle h) -> None"}, + PyDoc_STR("(IconFamilyHandle iconFamily, OSType iconType, Handle h) -> None")}, {"GetIconFamilyData", (PyCFunction)Icn_GetIconFamilyData, 1, - "(IconFamilyHandle iconFamily, OSType iconType, Handle h) -> None"}, + PyDoc_STR("(IconFamilyHandle iconFamily, OSType iconType, Handle h) -> None")}, {"GetIconRefOwners", (PyCFunction)Icn_GetIconRefOwners, 1, - "(IconRef theIconRef) -> (UInt16 owners)"}, + PyDoc_STR("(IconRef theIconRef) -> (UInt16 owners)")}, {"AcquireIconRef", (PyCFunction)Icn_AcquireIconRef, 1, - "(IconRef theIconRef) -> None"}, + PyDoc_STR("(IconRef theIconRef) -> None")}, {"ReleaseIconRef", (PyCFunction)Icn_ReleaseIconRef, 1, - "(IconRef theIconRef) -> None"}, + PyDoc_STR("(IconRef theIconRef) -> None")}, {"GetIconRefFromFile", (PyCFunction)Icn_GetIconRefFromFile, 1, - "(FSSpec theFile) -> (IconRef theIconRef, SInt16 theLabel)"}, + PyDoc_STR("(FSSpec theFile) -> (IconRef theIconRef, SInt16 theLabel)")}, {"GetIconRef", (PyCFunction)Icn_GetIconRef, 1, - "(SInt16 vRefNum, OSType creator, OSType iconType) -> (IconRef theIconRef)"}, + PyDoc_STR("(SInt16 vRefNum, OSType creator, OSType iconType) -> (IconRef theIconRef)")}, {"GetIconRefFromFolder", (PyCFunction)Icn_GetIconRefFromFolder, 1, - "(SInt16 vRefNum, SInt32 parentFolderID, SInt32 folderID, SInt8 attributes, SInt8 accessPrivileges) -> (IconRef theIconRef)"}, + PyDoc_STR("(SInt16 vRefNum, SInt32 parentFolderID, SInt32 folderID, SInt8 attributes, SInt8 accessPrivileges) -> (IconRef theIconRef)")}, {"RegisterIconRefFromIconFamily", (PyCFunction)Icn_RegisterIconRefFromIconFamily, 1, - "(OSType creator, OSType iconType, IconFamilyHandle iconFamily) -> (IconRef theIconRef)"}, + PyDoc_STR("(OSType creator, OSType iconType, IconFamilyHandle iconFamily) -> (IconRef theIconRef)")}, {"RegisterIconRefFromResource", (PyCFunction)Icn_RegisterIconRefFromResource, 1, - "(OSType creator, OSType iconType, FSSpec resourceFile, SInt16 resourceID) -> (IconRef theIconRef)"}, + PyDoc_STR("(OSType creator, OSType iconType, FSSpec resourceFile, SInt16 resourceID) -> (IconRef theIconRef)")}, {"UnregisterIconRef", (PyCFunction)Icn_UnregisterIconRef, 1, - "(OSType creator, OSType iconType) -> None"}, + PyDoc_STR("(OSType creator, OSType iconType) -> None")}, {"UpdateIconRef", (PyCFunction)Icn_UpdateIconRef, 1, - "(IconRef theIconRef) -> None"}, + PyDoc_STR("(IconRef theIconRef) -> None")}, {"OverrideIconRefFromResource", (PyCFunction)Icn_OverrideIconRefFromResource, 1, - "(IconRef theIconRef, FSSpec resourceFile, SInt16 resourceID) -> None"}, + PyDoc_STR("(IconRef theIconRef, FSSpec resourceFile, SInt16 resourceID) -> None")}, {"OverrideIconRef", (PyCFunction)Icn_OverrideIconRef, 1, - "(IconRef oldIconRef, IconRef newIconRef) -> None"}, + PyDoc_STR("(IconRef oldIconRef, IconRef newIconRef) -> None")}, {"RemoveIconRefOverride", (PyCFunction)Icn_RemoveIconRefOverride, 1, - "(IconRef theIconRef) -> None"}, + PyDoc_STR("(IconRef theIconRef) -> None")}, {"CompositeIconRef", (PyCFunction)Icn_CompositeIconRef, 1, - "(IconRef backgroundIconRef, IconRef foregroundIconRef) -> (IconRef compositeIconRef)"}, + PyDoc_STR("(IconRef backgroundIconRef, IconRef foregroundIconRef) -> (IconRef compositeIconRef)")}, {"IsIconRefComposite", (PyCFunction)Icn_IsIconRefComposite, 1, - "(IconRef compositeIconRef) -> (IconRef backgroundIconRef, IconRef foregroundIconRef)"}, + PyDoc_STR("(IconRef compositeIconRef) -> (IconRef backgroundIconRef, IconRef foregroundIconRef)")}, {"IsValidIconRef", (PyCFunction)Icn_IsValidIconRef, 1, - "(IconRef theIconRef) -> (Boolean _rv)"}, + PyDoc_STR("(IconRef theIconRef) -> (Boolean _rv)")}, {"PlotIconRef", (PyCFunction)Icn_PlotIconRef, 1, - "(Rect theRect, IconAlignmentType align, IconTransformType transform, IconServicesUsageFlags theIconServicesUsageFlags, IconRef theIconRef) -> None"}, + PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, IconServicesUsageFlags theIconServicesUsageFlags, IconRef theIconRef) -> None")}, {"PtInIconRef", (PyCFunction)Icn_PtInIconRef, 1, - "(Point testPt, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags theIconServicesUsageFlags, IconRef theIconRef) -> (Boolean _rv)"}, + PyDoc_STR("(Point testPt, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags theIconServicesUsageFlags, IconRef theIconRef) -> (Boolean _rv)")}, {"RectInIconRef", (PyCFunction)Icn_RectInIconRef, 1, - "(Rect testRect, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> (Boolean _rv)"}, + PyDoc_STR("(Rect testRect, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> (Boolean _rv)")}, {"IconRefToRgn", (PyCFunction)Icn_IconRefToRgn, 1, - "(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> None"}, + PyDoc_STR("(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> None")}, {"GetIconSizesFromIconRef", (PyCFunction)Icn_GetIconSizesFromIconRef, 1, - "(IconSelectorValue iconSelectorInput, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> (IconSelectorValue iconSelectorOutputPtr)"}, + PyDoc_STR("(IconSelectorValue iconSelectorInput, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> (IconSelectorValue iconSelectorOutputPtr)")}, {"FlushIconRefs", (PyCFunction)Icn_FlushIconRefs, 1, - "(OSType creator, OSType iconType) -> None"}, + PyDoc_STR("(OSType creator, OSType iconType) -> None")}, {"FlushIconRefsByVolume", (PyCFunction)Icn_FlushIconRefsByVolume, 1, - "(SInt16 vRefNum) -> None"}, + PyDoc_STR("(SInt16 vRefNum) -> None")}, {"SetCustomIconsEnabled", (PyCFunction)Icn_SetCustomIconsEnabled, 1, - "(SInt16 vRefNum, Boolean enableCustomIcons) -> None"}, + PyDoc_STR("(SInt16 vRefNum, Boolean enableCustomIcons) -> None")}, {"GetCustomIconsEnabled", (PyCFunction)Icn_GetCustomIconsEnabled, 1, - "(SInt16 vRefNum) -> (Boolean customIconsEnabled)"}, + PyDoc_STR("(SInt16 vRefNum) -> (Boolean customIconsEnabled)")}, {"IsIconRefMaskEmpty", (PyCFunction)Icn_IsIconRefMaskEmpty, 1, - "(IconRef iconRef) -> (Boolean _rv)"}, + PyDoc_STR("(IconRef iconRef) -> (Boolean _rv)")}, #if TARGET_API_MAC_CARBON {"GetIconRefVariant", (PyCFunction)Icn_GetIconRefVariant, 1, - "(IconRef inIconRef, OSType inVariant) -> (IconRef _rv, IconTransformType outTransform)"}, + PyDoc_STR("(IconRef inIconRef, OSType inVariant) -> (IconRef _rv, IconTransformType outTransform)")}, #endif #if TARGET_API_MAC_CARBON {"RegisterIconRefFromIconFile", (PyCFunction)Icn_RegisterIconRefFromIconFile, 1, - "(OSType creator, OSType iconType, FSSpec iconFile) -> (IconRef theIconRef)"}, + PyDoc_STR("(OSType creator, OSType iconType, FSSpec iconFile) -> (IconRef theIconRef)")}, #endif #if TARGET_API_MAC_CARBON {"ReadIconFile", (PyCFunction)Icn_ReadIconFile, 1, - "(FSSpec iconFile) -> (IconFamilyHandle iconFamily)"}, + PyDoc_STR("(FSSpec iconFile) -> (IconFamilyHandle iconFamily)")}, #endif #if TARGET_API_MAC_CARBON {"WriteIconFile", (PyCFunction)Icn_WriteIconFile, 1, - "(IconFamilyHandle iconFamily, FSSpec iconFile) -> None"}, + PyDoc_STR("(IconFamilyHandle iconFamily, FSSpec iconFile) -> None")}, #endif {NULL, NULL, 0} }; diff --git a/Mac/Modules/list/_Listmodule.c b/Mac/Modules/list/_Listmodule.c index 85c4d61..99805b6 100644 --- a/Mac/Modules/list/_Listmodule.c +++ b/Mac/Modules/list/_Listmodule.c @@ -556,53 +556,53 @@ static PyObject *ListObj_as_Resource(ListObject *_self, PyObject *_args) static PyMethodDef ListObj_methods[] = { {"LAddColumn", (PyCFunction)ListObj_LAddColumn, 1, - "(short count, short colNum) -> (short _rv)"}, + PyDoc_STR("(short count, short colNum) -> (short _rv)")}, {"LAddRow", (PyCFunction)ListObj_LAddRow, 1, - "(short count, short rowNum) -> (short _rv)"}, + PyDoc_STR("(short count, short rowNum) -> (short _rv)")}, {"LDelColumn", (PyCFunction)ListObj_LDelColumn, 1, - "(short count, short colNum) -> None"}, + PyDoc_STR("(short count, short colNum) -> None")}, {"LDelRow", (PyCFunction)ListObj_LDelRow, 1, - "(short count, short rowNum) -> None"}, + PyDoc_STR("(short count, short rowNum) -> None")}, {"LGetSelect", (PyCFunction)ListObj_LGetSelect, 1, - "(Boolean next, Point theCell) -> (Boolean _rv, Point theCell)"}, + PyDoc_STR("(Boolean next, Point theCell) -> (Boolean _rv, Point theCell)")}, {"LLastClick", (PyCFunction)ListObj_LLastClick, 1, - "() -> (Point _rv)"}, + PyDoc_STR("() -> (Point _rv)")}, {"LNextCell", (PyCFunction)ListObj_LNextCell, 1, - "(Boolean hNext, Boolean vNext, Point theCell) -> (Boolean _rv, Point theCell)"}, + PyDoc_STR("(Boolean hNext, Boolean vNext, Point theCell) -> (Boolean _rv, Point theCell)")}, {"LSize", (PyCFunction)ListObj_LSize, 1, - "(short listWidth, short listHeight) -> None"}, + PyDoc_STR("(short listWidth, short listHeight) -> None")}, {"LSetDrawingMode", (PyCFunction)ListObj_LSetDrawingMode, 1, - "(Boolean drawIt) -> None"}, + PyDoc_STR("(Boolean drawIt) -> None")}, {"LScroll", (PyCFunction)ListObj_LScroll, 1, - "(short dCols, short dRows) -> None"}, + PyDoc_STR("(short dCols, short dRows) -> None")}, {"LAutoScroll", (PyCFunction)ListObj_LAutoScroll, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"LUpdate", (PyCFunction)ListObj_LUpdate, 1, - "(RgnHandle theRgn) -> None"}, + PyDoc_STR("(RgnHandle theRgn) -> None")}, {"LActivate", (PyCFunction)ListObj_LActivate, 1, - "(Boolean act) -> None"}, + PyDoc_STR("(Boolean act) -> None")}, {"LCellSize", (PyCFunction)ListObj_LCellSize, 1, - "(Point cSize) -> None"}, + PyDoc_STR("(Point cSize) -> None")}, {"LClick", (PyCFunction)ListObj_LClick, 1, - "(Point pt, EventModifiers modifiers) -> (Boolean _rv)"}, + PyDoc_STR("(Point pt, EventModifiers modifiers) -> (Boolean _rv)")}, {"LAddToCell", (PyCFunction)ListObj_LAddToCell, 1, - "(Buffer dataPtr, Point theCell) -> None"}, + PyDoc_STR("(Buffer dataPtr, Point theCell) -> None")}, {"LClrCell", (PyCFunction)ListObj_LClrCell, 1, - "(Point theCell) -> None"}, + PyDoc_STR("(Point theCell) -> None")}, {"LGetCell", (PyCFunction)ListObj_LGetCell, 1, - "(Buffer dataPtr, Point theCell) -> (Buffer dataPtr)"}, + PyDoc_STR("(Buffer dataPtr, Point theCell) -> (Buffer dataPtr)")}, {"LRect", (PyCFunction)ListObj_LRect, 1, - "(Point theCell) -> (Rect cellRect)"}, + PyDoc_STR("(Point theCell) -> (Rect cellRect)")}, {"LSetCell", (PyCFunction)ListObj_LSetCell, 1, - "(Buffer dataPtr, Point theCell) -> None"}, + PyDoc_STR("(Buffer dataPtr, Point theCell) -> None")}, {"LSetSelect", (PyCFunction)ListObj_LSetSelect, 1, - "(Boolean setIt, Point theCell) -> None"}, + PyDoc_STR("(Boolean setIt, Point theCell) -> None")}, {"LDraw", (PyCFunction)ListObj_LDraw, 1, - "(Point theCell) -> None"}, + PyDoc_STR("(Point theCell) -> None")}, {"LGetCellDataLocation", (PyCFunction)ListObj_LGetCellDataLocation, 1, - "(Point theCell) -> (short offset, short len)"}, + PyDoc_STR("(Point theCell) -> (short offset, short len)")}, {"as_Resource", (PyCFunction)ListObj_as_Resource, 1, - "() -> (Handle _rv)"}, + PyDoc_STR("() -> (Handle _rv)")}, {NULL, NULL, 0} }; @@ -1082,49 +1082,49 @@ static PyObject *List_as_List(PyObject *_self, PyObject *_args) static PyMethodDef List_methods[] = { {"CreateCustomList", (PyCFunction)List_CreateCustomList, 1, - "(Rect rView, Rect dataBounds, Point cellSize, ListDefSpec theSpec, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListHandle outList)"}, + PyDoc_STR("(Rect rView, Rect dataBounds, Point cellSize, ListDefSpec theSpec, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListHandle outList)")}, {"LNew", (PyCFunction)List_LNew, 1, - "(Rect rView, Rect dataBounds, Point cSize, short theProc, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListHandle _rv)"}, + PyDoc_STR("(Rect rView, Rect dataBounds, Point cSize, short theProc, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListHandle _rv)")}, {"GetListPort", (PyCFunction)List_GetListPort, 1, - "(ListHandle list) -> (CGrafPtr _rv)"}, + PyDoc_STR("(ListHandle list) -> (CGrafPtr _rv)")}, {"GetListVerticalScrollBar", (PyCFunction)List_GetListVerticalScrollBar, 1, - "(ListHandle list) -> (ControlHandle _rv)"}, + PyDoc_STR("(ListHandle list) -> (ControlHandle _rv)")}, {"GetListHorizontalScrollBar", (PyCFunction)List_GetListHorizontalScrollBar, 1, - "(ListHandle list) -> (ControlHandle _rv)"}, + PyDoc_STR("(ListHandle list) -> (ControlHandle _rv)")}, {"GetListActive", (PyCFunction)List_GetListActive, 1, - "(ListHandle list) -> (Boolean _rv)"}, + PyDoc_STR("(ListHandle list) -> (Boolean _rv)")}, {"GetListClickTime", (PyCFunction)List_GetListClickTime, 1, - "(ListHandle list) -> (SInt32 _rv)"}, + PyDoc_STR("(ListHandle list) -> (SInt32 _rv)")}, {"GetListRefCon", (PyCFunction)List_GetListRefCon, 1, - "(ListHandle list) -> (SInt32 _rv)"}, + PyDoc_STR("(ListHandle list) -> (SInt32 _rv)")}, {"GetListDefinition", (PyCFunction)List_GetListDefinition, 1, - "(ListHandle list) -> (Handle _rv)"}, + PyDoc_STR("(ListHandle list) -> (Handle _rv)")}, {"GetListUserHandle", (PyCFunction)List_GetListUserHandle, 1, - "(ListHandle list) -> (Handle _rv)"}, + PyDoc_STR("(ListHandle list) -> (Handle _rv)")}, {"GetListDataHandle", (PyCFunction)List_GetListDataHandle, 1, - "(ListHandle list) -> (DataHandle _rv)"}, + PyDoc_STR("(ListHandle list) -> (DataHandle _rv)")}, {"GetListFlags", (PyCFunction)List_GetListFlags, 1, - "(ListHandle list) -> (OptionBits _rv)"}, + PyDoc_STR("(ListHandle list) -> (OptionBits _rv)")}, {"GetListSelectionFlags", (PyCFunction)List_GetListSelectionFlags, 1, - "(ListHandle list) -> (OptionBits _rv)"}, + PyDoc_STR("(ListHandle list) -> (OptionBits _rv)")}, {"SetListViewBounds", (PyCFunction)List_SetListViewBounds, 1, - "(ListHandle list, Rect view) -> None"}, + PyDoc_STR("(ListHandle list, Rect view) -> None")}, {"SetListPort", (PyCFunction)List_SetListPort, 1, - "(ListHandle list, CGrafPtr port) -> None"}, + PyDoc_STR("(ListHandle list, CGrafPtr port) -> None")}, {"SetListCellIndent", (PyCFunction)List_SetListCellIndent, 1, - "(ListHandle list, Point indent) -> None"}, + PyDoc_STR("(ListHandle list, Point indent) -> None")}, {"SetListClickTime", (PyCFunction)List_SetListClickTime, 1, - "(ListHandle list, SInt32 time) -> None"}, + PyDoc_STR("(ListHandle list, SInt32 time) -> None")}, {"SetListRefCon", (PyCFunction)List_SetListRefCon, 1, - "(ListHandle list, SInt32 refCon) -> None"}, + PyDoc_STR("(ListHandle list, SInt32 refCon) -> None")}, {"SetListUserHandle", (PyCFunction)List_SetListUserHandle, 1, - "(ListHandle list, Handle userHandle) -> None"}, + PyDoc_STR("(ListHandle list, Handle userHandle) -> None")}, {"SetListFlags", (PyCFunction)List_SetListFlags, 1, - "(ListHandle list, OptionBits listFlags) -> None"}, + PyDoc_STR("(ListHandle list, OptionBits listFlags) -> None")}, {"SetListSelectionFlags", (PyCFunction)List_SetListSelectionFlags, 1, - "(ListHandle list, OptionBits selectionFlags) -> None"}, + PyDoc_STR("(ListHandle list, OptionBits selectionFlags) -> None")}, {"as_List", (PyCFunction)List_as_List, 1, - "(Resource)->List.\nReturns List object (which is not auto-freed!)"}, + PyDoc_STR("(Resource)->List.\nReturns List object (which is not auto-freed!)")}, {NULL, NULL, 0} }; diff --git a/Mac/Modules/menu/_Menumodule.c b/Mac/Modules/menu/_Menumodule.c index dd369c1..bf860fe 100644 --- a/Mac/Modules/menu/_Menumodule.c +++ b/Mac/Modules/menu/_Menumodule.c @@ -2597,406 +2597,406 @@ static PyObject *MenuObj_CheckMenuItem(MenuObject *_self, PyObject *_args) static PyMethodDef MenuObj_methods[] = { {"DisposeMenu", (PyCFunction)MenuObj_DisposeMenu, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CalcMenuSize", (PyCFunction)MenuObj_CalcMenuSize, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #if !TARGET_API_MAC_CARBON {"CountMItems", (PyCFunction)MenuObj_CountMItems, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, #endif {"CountMenuItems", (PyCFunction)MenuObj_CountMenuItems, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, {"GetMenuFont", (PyCFunction)MenuObj_GetMenuFont, 1, - "() -> (SInt16 outFontID, UInt16 outFontSize)"}, + PyDoc_STR("() -> (SInt16 outFontID, UInt16 outFontSize)")}, {"SetMenuFont", (PyCFunction)MenuObj_SetMenuFont, 1, - "(SInt16 inFontID, UInt16 inFontSize) -> None"}, + PyDoc_STR("(SInt16 inFontID, UInt16 inFontSize) -> None")}, {"GetMenuExcludesMarkColumn", (PyCFunction)MenuObj_GetMenuExcludesMarkColumn, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, {"SetMenuExcludesMarkColumn", (PyCFunction)MenuObj_SetMenuExcludesMarkColumn, 1, - "(Boolean excludesMark) -> None"}, + PyDoc_STR("(Boolean excludesMark) -> None")}, #if TARGET_API_MAC_CARBON {"IsValidMenu", (PyCFunction)MenuObj_IsValidMenu, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, #endif #if TARGET_API_MAC_CARBON {"GetMenuRetainCount", (PyCFunction)MenuObj_GetMenuRetainCount, 1, - "() -> (ItemCount _rv)"}, + PyDoc_STR("() -> (ItemCount _rv)")}, #endif #if TARGET_API_MAC_CARBON {"RetainMenu", (PyCFunction)MenuObj_RetainMenu, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if TARGET_API_MAC_CARBON {"ReleaseMenu", (PyCFunction)MenuObj_ReleaseMenu, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if TARGET_API_MAC_CARBON {"DuplicateMenu", (PyCFunction)MenuObj_DuplicateMenu, 1, - "() -> (MenuHandle outMenu)"}, + PyDoc_STR("() -> (MenuHandle outMenu)")}, #endif #if TARGET_API_MAC_CARBON {"CopyMenuTitleAsCFString", (PyCFunction)MenuObj_CopyMenuTitleAsCFString, 1, - "() -> (CFStringRef outString)"}, + PyDoc_STR("() -> (CFStringRef outString)")}, #endif #if TARGET_API_MAC_CARBON {"SetMenuTitleWithCFString", (PyCFunction)MenuObj_SetMenuTitleWithCFString, 1, - "(CFStringRef inString) -> None"}, + PyDoc_STR("(CFStringRef inString) -> None")}, #endif #if TARGET_API_MAC_CARBON {"InvalidateMenuSize", (PyCFunction)MenuObj_InvalidateMenuSize, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if TARGET_API_MAC_CARBON {"IsMenuSizeInvalid", (PyCFunction)MenuObj_IsMenuSizeInvalid, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, #endif {"MacAppendMenu", (PyCFunction)MenuObj_MacAppendMenu, 1, - "(Str255 data) -> None"}, + PyDoc_STR("(Str255 data) -> None")}, {"InsertResMenu", (PyCFunction)MenuObj_InsertResMenu, 1, - "(ResType theType, short afterItem) -> None"}, + PyDoc_STR("(ResType theType, short afterItem) -> None")}, {"AppendResMenu", (PyCFunction)MenuObj_AppendResMenu, 1, - "(ResType theType) -> None"}, + PyDoc_STR("(ResType theType) -> None")}, {"MacInsertMenuItem", (PyCFunction)MenuObj_MacInsertMenuItem, 1, - "(Str255 itemString, short afterItem) -> None"}, + PyDoc_STR("(Str255 itemString, short afterItem) -> None")}, {"DeleteMenuItem", (PyCFunction)MenuObj_DeleteMenuItem, 1, - "(short item) -> None"}, + PyDoc_STR("(short item) -> None")}, {"InsertFontResMenu", (PyCFunction)MenuObj_InsertFontResMenu, 1, - "(short afterItem, short scriptFilter) -> None"}, + PyDoc_STR("(short afterItem, short scriptFilter) -> None")}, {"InsertIntlResMenu", (PyCFunction)MenuObj_InsertIntlResMenu, 1, - "(ResType theType, short afterItem, short scriptFilter) -> None"}, + PyDoc_STR("(ResType theType, short afterItem, short scriptFilter) -> None")}, {"AppendMenuItemText", (PyCFunction)MenuObj_AppendMenuItemText, 1, - "(Str255 inString) -> None"}, + PyDoc_STR("(Str255 inString) -> None")}, {"InsertMenuItemText", (PyCFunction)MenuObj_InsertMenuItemText, 1, - "(Str255 inString, MenuItemIndex afterItem) -> None"}, + PyDoc_STR("(Str255 inString, MenuItemIndex afterItem) -> None")}, #if TARGET_API_MAC_CARBON {"CopyMenuItems", (PyCFunction)MenuObj_CopyMenuItems, 1, - "(MenuItemIndex inFirstItem, ItemCount inNumItems, MenuHandle inDestMenu, MenuItemIndex inInsertAfter) -> None"}, + PyDoc_STR("(MenuItemIndex inFirstItem, ItemCount inNumItems, MenuHandle inDestMenu, MenuItemIndex inInsertAfter) -> None")}, #endif #if TARGET_API_MAC_CARBON {"DeleteMenuItems", (PyCFunction)MenuObj_DeleteMenuItems, 1, - "(MenuItemIndex inFirstItem, ItemCount inNumItems) -> None"}, + PyDoc_STR("(MenuItemIndex inFirstItem, ItemCount inNumItems) -> None")}, #endif #if TARGET_API_MAC_CARBON {"AppendMenuItemTextWithCFString", (PyCFunction)MenuObj_AppendMenuItemTextWithCFString, 1, - "(CFStringRef inString, MenuItemAttributes inAttributes, MenuCommand inCommandID) -> (MenuItemIndex outNewItem)"}, + PyDoc_STR("(CFStringRef inString, MenuItemAttributes inAttributes, MenuCommand inCommandID) -> (MenuItemIndex outNewItem)")}, #endif #if TARGET_API_MAC_CARBON {"InsertMenuItemTextWithCFString", (PyCFunction)MenuObj_InsertMenuItemTextWithCFString, 1, - "(CFStringRef inString, MenuItemIndex inAfterItem, MenuItemAttributes inAttributes, MenuCommand inCommandID) -> None"}, + PyDoc_STR("(CFStringRef inString, MenuItemIndex inAfterItem, MenuItemAttributes inAttributes, MenuCommand inCommandID) -> None")}, #endif {"PopUpMenuSelect", (PyCFunction)MenuObj_PopUpMenuSelect, 1, - "(short top, short left, short popUpItem) -> (long _rv)"}, + PyDoc_STR("(short top, short left, short popUpItem) -> (long _rv)")}, #if TARGET_API_MAC_CARBON {"InvalidateMenuEnabling", (PyCFunction)MenuObj_InvalidateMenuEnabling, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if TARGET_API_MAC_CARBON {"IsMenuBarInvalid", (PyCFunction)MenuObj_IsMenuBarInvalid, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, #endif {"MacInsertMenu", (PyCFunction)MenuObj_MacInsertMenu, 1, - "(MenuID beforeID) -> None"}, + PyDoc_STR("(MenuID beforeID) -> None")}, #if TARGET_API_MAC_CARBON {"SetRootMenu", (PyCFunction)MenuObj_SetRootMenu, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if !TARGET_API_MAC_CARBON {"CheckItem", (PyCFunction)MenuObj_CheckItem, 1, - "(short item, Boolean checked) -> None"}, + PyDoc_STR("(short item, Boolean checked) -> None")}, #endif {"MacCheckMenuItem", (PyCFunction)MenuObj_MacCheckMenuItem, 1, - "(short item, Boolean checked) -> None"}, + PyDoc_STR("(short item, Boolean checked) -> None")}, {"SetMenuItemText", (PyCFunction)MenuObj_SetMenuItemText, 1, - "(short item, Str255 itemString) -> None"}, + PyDoc_STR("(short item, Str255 itemString) -> None")}, {"GetMenuItemText", (PyCFunction)MenuObj_GetMenuItemText, 1, - "(short item) -> (Str255 itemString)"}, + PyDoc_STR("(short item) -> (Str255 itemString)")}, {"SetItemMark", (PyCFunction)MenuObj_SetItemMark, 1, - "(short item, CharParameter markChar) -> None"}, + PyDoc_STR("(short item, CharParameter markChar) -> None")}, {"GetItemMark", (PyCFunction)MenuObj_GetItemMark, 1, - "(short item) -> (CharParameter markChar)"}, + PyDoc_STR("(short item) -> (CharParameter markChar)")}, {"SetItemCmd", (PyCFunction)MenuObj_SetItemCmd, 1, - "(short item, CharParameter cmdChar) -> None"}, + PyDoc_STR("(short item, CharParameter cmdChar) -> None")}, {"GetItemCmd", (PyCFunction)MenuObj_GetItemCmd, 1, - "(short item) -> (CharParameter cmdChar)"}, + PyDoc_STR("(short item) -> (CharParameter cmdChar)")}, {"SetItemIcon", (PyCFunction)MenuObj_SetItemIcon, 1, - "(short item, short iconIndex) -> None"}, + PyDoc_STR("(short item, short iconIndex) -> None")}, {"GetItemIcon", (PyCFunction)MenuObj_GetItemIcon, 1, - "(short item) -> (short iconIndex)"}, + PyDoc_STR("(short item) -> (short iconIndex)")}, {"SetItemStyle", (PyCFunction)MenuObj_SetItemStyle, 1, - "(short item, StyleParameter chStyle) -> None"}, + PyDoc_STR("(short item, StyleParameter chStyle) -> None")}, {"GetItemStyle", (PyCFunction)MenuObj_GetItemStyle, 1, - "(short item) -> (Style chStyle)"}, + PyDoc_STR("(short item) -> (Style chStyle)")}, #if !TARGET_API_MAC_CARBON {"DisableItem", (PyCFunction)MenuObj_DisableItem, 1, - "(short item) -> None"}, + PyDoc_STR("(short item) -> None")}, #endif #if !TARGET_API_MAC_CARBON {"EnableItem", (PyCFunction)MenuObj_EnableItem, 1, - "(short item) -> None"}, + PyDoc_STR("(short item) -> None")}, #endif {"SetMenuItemCommandID", (PyCFunction)MenuObj_SetMenuItemCommandID, 1, - "(SInt16 inItem, MenuCommand inCommandID) -> None"}, + PyDoc_STR("(SInt16 inItem, MenuCommand inCommandID) -> None")}, {"GetMenuItemCommandID", (PyCFunction)MenuObj_GetMenuItemCommandID, 1, - "(SInt16 inItem) -> (MenuCommand outCommandID)"}, + PyDoc_STR("(SInt16 inItem) -> (MenuCommand outCommandID)")}, {"SetMenuItemModifiers", (PyCFunction)MenuObj_SetMenuItemModifiers, 1, - "(SInt16 inItem, UInt8 inModifiers) -> None"}, + PyDoc_STR("(SInt16 inItem, UInt8 inModifiers) -> None")}, {"GetMenuItemModifiers", (PyCFunction)MenuObj_GetMenuItemModifiers, 1, - "(SInt16 inItem) -> (UInt8 outModifiers)"}, + PyDoc_STR("(SInt16 inItem) -> (UInt8 outModifiers)")}, {"SetMenuItemIconHandle", (PyCFunction)MenuObj_SetMenuItemIconHandle, 1, - "(SInt16 inItem, UInt8 inIconType, Handle inIconHandle) -> None"}, + PyDoc_STR("(SInt16 inItem, UInt8 inIconType, Handle inIconHandle) -> None")}, {"GetMenuItemIconHandle", (PyCFunction)MenuObj_GetMenuItemIconHandle, 1, - "(SInt16 inItem) -> (UInt8 outIconType, Handle outIconHandle)"}, + PyDoc_STR("(SInt16 inItem) -> (UInt8 outIconType, Handle outIconHandle)")}, {"SetMenuItemTextEncoding", (PyCFunction)MenuObj_SetMenuItemTextEncoding, 1, - "(SInt16 inItem, TextEncoding inScriptID) -> None"}, + PyDoc_STR("(SInt16 inItem, TextEncoding inScriptID) -> None")}, {"GetMenuItemTextEncoding", (PyCFunction)MenuObj_GetMenuItemTextEncoding, 1, - "(SInt16 inItem) -> (TextEncoding outScriptID)"}, + PyDoc_STR("(SInt16 inItem) -> (TextEncoding outScriptID)")}, {"SetMenuItemHierarchicalID", (PyCFunction)MenuObj_SetMenuItemHierarchicalID, 1, - "(SInt16 inItem, MenuID inHierID) -> None"}, + PyDoc_STR("(SInt16 inItem, MenuID inHierID) -> None")}, {"GetMenuItemHierarchicalID", (PyCFunction)MenuObj_GetMenuItemHierarchicalID, 1, - "(SInt16 inItem) -> (MenuID outHierID)"}, + PyDoc_STR("(SInt16 inItem) -> (MenuID outHierID)")}, {"SetMenuItemFontID", (PyCFunction)MenuObj_SetMenuItemFontID, 1, - "(SInt16 inItem, SInt16 inFontID) -> None"}, + PyDoc_STR("(SInt16 inItem, SInt16 inFontID) -> None")}, {"GetMenuItemFontID", (PyCFunction)MenuObj_GetMenuItemFontID, 1, - "(SInt16 inItem) -> (SInt16 outFontID)"}, + PyDoc_STR("(SInt16 inItem) -> (SInt16 outFontID)")}, {"SetMenuItemRefCon", (PyCFunction)MenuObj_SetMenuItemRefCon, 1, - "(SInt16 inItem, UInt32 inRefCon) -> None"}, + PyDoc_STR("(SInt16 inItem, UInt32 inRefCon) -> None")}, {"GetMenuItemRefCon", (PyCFunction)MenuObj_GetMenuItemRefCon, 1, - "(SInt16 inItem) -> (UInt32 outRefCon)"}, + PyDoc_STR("(SInt16 inItem) -> (UInt32 outRefCon)")}, #if !TARGET_API_MAC_CARBON {"SetMenuItemRefCon2", (PyCFunction)MenuObj_SetMenuItemRefCon2, 1, - "(SInt16 inItem, UInt32 inRefCon2) -> None"}, + PyDoc_STR("(SInt16 inItem, UInt32 inRefCon2) -> None")}, #endif #if !TARGET_API_MAC_CARBON {"GetMenuItemRefCon2", (PyCFunction)MenuObj_GetMenuItemRefCon2, 1, - "(SInt16 inItem) -> (UInt32 outRefCon2)"}, + PyDoc_STR("(SInt16 inItem) -> (UInt32 outRefCon2)")}, #endif {"SetMenuItemKeyGlyph", (PyCFunction)MenuObj_SetMenuItemKeyGlyph, 1, - "(SInt16 inItem, SInt16 inGlyph) -> None"}, + PyDoc_STR("(SInt16 inItem, SInt16 inGlyph) -> None")}, {"GetMenuItemKeyGlyph", (PyCFunction)MenuObj_GetMenuItemKeyGlyph, 1, - "(SInt16 inItem) -> (SInt16 outGlyph)"}, + PyDoc_STR("(SInt16 inItem) -> (SInt16 outGlyph)")}, {"MacEnableMenuItem", (PyCFunction)MenuObj_MacEnableMenuItem, 1, - "(MenuItemIndex item) -> None"}, + PyDoc_STR("(MenuItemIndex item) -> None")}, {"DisableMenuItem", (PyCFunction)MenuObj_DisableMenuItem, 1, - "(MenuItemIndex item) -> None"}, + PyDoc_STR("(MenuItemIndex item) -> None")}, {"IsMenuItemEnabled", (PyCFunction)MenuObj_IsMenuItemEnabled, 1, - "(MenuItemIndex item) -> (Boolean _rv)"}, + PyDoc_STR("(MenuItemIndex item) -> (Boolean _rv)")}, {"EnableMenuItemIcon", (PyCFunction)MenuObj_EnableMenuItemIcon, 1, - "(MenuItemIndex item) -> None"}, + PyDoc_STR("(MenuItemIndex item) -> None")}, {"DisableMenuItemIcon", (PyCFunction)MenuObj_DisableMenuItemIcon, 1, - "(MenuItemIndex item) -> None"}, + PyDoc_STR("(MenuItemIndex item) -> None")}, {"IsMenuItemIconEnabled", (PyCFunction)MenuObj_IsMenuItemIconEnabled, 1, - "(MenuItemIndex item) -> (Boolean _rv)"}, + PyDoc_STR("(MenuItemIndex item) -> (Boolean _rv)")}, #if TARGET_API_MAC_CARBON {"SetMenuItemHierarchicalMenu", (PyCFunction)MenuObj_SetMenuItemHierarchicalMenu, 1, - "(MenuItemIndex inItem, MenuHandle inHierMenu) -> None"}, + PyDoc_STR("(MenuItemIndex inItem, MenuHandle inHierMenu) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetMenuItemHierarchicalMenu", (PyCFunction)MenuObj_GetMenuItemHierarchicalMenu, 1, - "(MenuItemIndex inItem) -> (MenuHandle outHierMenu)"}, + PyDoc_STR("(MenuItemIndex inItem) -> (MenuHandle outHierMenu)")}, #endif #if TARGET_API_MAC_CARBON {"CopyMenuItemTextAsCFString", (PyCFunction)MenuObj_CopyMenuItemTextAsCFString, 1, - "(MenuItemIndex inItem) -> (CFStringRef outString)"}, + PyDoc_STR("(MenuItemIndex inItem) -> (CFStringRef outString)")}, #endif #if TARGET_API_MAC_CARBON {"SetMenuItemTextWithCFString", (PyCFunction)MenuObj_SetMenuItemTextWithCFString, 1, - "(MenuItemIndex inItem, CFStringRef inString) -> None"}, + PyDoc_STR("(MenuItemIndex inItem, CFStringRef inString) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetMenuItemIndent", (PyCFunction)MenuObj_GetMenuItemIndent, 1, - "(MenuItemIndex inItem) -> (UInt32 outIndent)"}, + PyDoc_STR("(MenuItemIndex inItem) -> (UInt32 outIndent)")}, #endif #if TARGET_API_MAC_CARBON {"SetMenuItemIndent", (PyCFunction)MenuObj_SetMenuItemIndent, 1, - "(MenuItemIndex inItem, UInt32 inIndent) -> None"}, + PyDoc_STR("(MenuItemIndex inItem, UInt32 inIndent) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetMenuItemCommandKey", (PyCFunction)MenuObj_GetMenuItemCommandKey, 1, - "(MenuItemIndex inItem, Boolean inGetVirtualKey) -> (UInt16 outKey)"}, + PyDoc_STR("(MenuItemIndex inItem, Boolean inGetVirtualKey) -> (UInt16 outKey)")}, #endif #if TARGET_API_MAC_CARBON {"SetMenuItemCommandKey", (PyCFunction)MenuObj_SetMenuItemCommandKey, 1, - "(MenuItemIndex inItem, Boolean inSetVirtualKey, UInt16 inKey) -> None"}, + PyDoc_STR("(MenuItemIndex inItem, Boolean inSetVirtualKey, UInt16 inKey) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetMenuItemPropertyAttributes", (PyCFunction)MenuObj_GetMenuItemPropertyAttributes, 1, - "(MenuItemIndex item, OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)"}, + PyDoc_STR("(MenuItemIndex item, OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)")}, #endif #if TARGET_API_MAC_CARBON {"ChangeMenuItemPropertyAttributes", (PyCFunction)MenuObj_ChangeMenuItemPropertyAttributes, 1, - "(MenuItemIndex item, OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None"}, + PyDoc_STR("(MenuItemIndex item, OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetMenuAttributes", (PyCFunction)MenuObj_GetMenuAttributes, 1, - "() -> (MenuAttributes outAttributes)"}, + PyDoc_STR("() -> (MenuAttributes outAttributes)")}, #endif #if TARGET_API_MAC_CARBON {"ChangeMenuAttributes", (PyCFunction)MenuObj_ChangeMenuAttributes, 1, - "(MenuAttributes setTheseAttributes, MenuAttributes clearTheseAttributes) -> None"}, + PyDoc_STR("(MenuAttributes setTheseAttributes, MenuAttributes clearTheseAttributes) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetMenuItemAttributes", (PyCFunction)MenuObj_GetMenuItemAttributes, 1, - "(MenuItemIndex item) -> (MenuItemAttributes outAttributes)"}, + PyDoc_STR("(MenuItemIndex item) -> (MenuItemAttributes outAttributes)")}, #endif #if TARGET_API_MAC_CARBON {"ChangeMenuItemAttributes", (PyCFunction)MenuObj_ChangeMenuItemAttributes, 1, - "(MenuItemIndex item, MenuItemAttributes setTheseAttributes, MenuItemAttributes clearTheseAttributes) -> None"}, + PyDoc_STR("(MenuItemIndex item, MenuItemAttributes setTheseAttributes, MenuItemAttributes clearTheseAttributes) -> None")}, #endif #if TARGET_API_MAC_CARBON {"DisableAllMenuItems", (PyCFunction)MenuObj_DisableAllMenuItems, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if TARGET_API_MAC_CARBON {"EnableAllMenuItems", (PyCFunction)MenuObj_EnableAllMenuItems, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if TARGET_API_MAC_CARBON {"MenuHasEnabledItems", (PyCFunction)MenuObj_MenuHasEnabledItems, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, #endif #if TARGET_API_MAC_CARBON {"GetMenuType", (PyCFunction)MenuObj_GetMenuType, 1, - "() -> (UInt16 outType)"}, + PyDoc_STR("() -> (UInt16 outType)")}, #endif #if TARGET_API_MAC_CARBON {"CountMenuItemsWithCommandID", (PyCFunction)MenuObj_CountMenuItemsWithCommandID, 1, - "(MenuCommand inCommandID) -> (ItemCount _rv)"}, + PyDoc_STR("(MenuCommand inCommandID) -> (ItemCount _rv)")}, #endif #if TARGET_API_MAC_CARBON {"GetIndMenuItemWithCommandID", (PyCFunction)MenuObj_GetIndMenuItemWithCommandID, 1, - "(MenuCommand inCommandID, UInt32 inItemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)"}, + PyDoc_STR("(MenuCommand inCommandID, UInt32 inItemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)")}, #endif #if TARGET_API_MAC_CARBON {"EnableMenuCommand", (PyCFunction)MenuObj_EnableMenuCommand, 1, - "(MenuCommand inCommandID) -> None"}, + PyDoc_STR("(MenuCommand inCommandID) -> None")}, #endif #if TARGET_API_MAC_CARBON {"DisableMenuCommand", (PyCFunction)MenuObj_DisableMenuCommand, 1, - "(MenuCommand inCommandID) -> None"}, + PyDoc_STR("(MenuCommand inCommandID) -> None")}, #endif #if TARGET_API_MAC_CARBON {"IsMenuCommandEnabled", (PyCFunction)MenuObj_IsMenuCommandEnabled, 1, - "(MenuCommand inCommandID) -> (Boolean _rv)"}, + PyDoc_STR("(MenuCommand inCommandID) -> (Boolean _rv)")}, #endif #if TARGET_API_MAC_CARBON {"SetMenuCommandMark", (PyCFunction)MenuObj_SetMenuCommandMark, 1, - "(MenuCommand inCommandID, UniChar inMark) -> None"}, + PyDoc_STR("(MenuCommand inCommandID, UniChar inMark) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetMenuCommandMark", (PyCFunction)MenuObj_GetMenuCommandMark, 1, - "(MenuCommand inCommandID) -> (UniChar outMark)"}, + PyDoc_STR("(MenuCommand inCommandID) -> (UniChar outMark)")}, #endif #if TARGET_API_MAC_CARBON {"GetMenuCommandPropertySize", (PyCFunction)MenuObj_GetMenuCommandPropertySize, 1, - "(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> (ByteCount outSize)"}, + PyDoc_STR("(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> (ByteCount outSize)")}, #endif #if TARGET_API_MAC_CARBON {"RemoveMenuCommandProperty", (PyCFunction)MenuObj_RemoveMenuCommandProperty, 1, - "(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> None"}, + PyDoc_STR("(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> None")}, #endif #if TARGET_API_MAC_CARBON {"IsMenuItemInvalid", (PyCFunction)MenuObj_IsMenuItemInvalid, 1, - "(MenuItemIndex item) -> (Boolean _rv)"}, + PyDoc_STR("(MenuItemIndex item) -> (Boolean _rv)")}, #endif #if TARGET_API_MAC_CARBON {"InvalidateMenuItems", (PyCFunction)MenuObj_InvalidateMenuItems, 1, - "(MenuItemIndex firstItem, ItemCount numItems) -> None"}, + PyDoc_STR("(MenuItemIndex firstItem, ItemCount numItems) -> None")}, #endif #if TARGET_API_MAC_CARBON {"UpdateInvalidMenuItems", (PyCFunction)MenuObj_UpdateInvalidMenuItems, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if TARGET_API_MAC_CARBON {"CreateStandardFontMenu", (PyCFunction)MenuObj_CreateStandardFontMenu, 1, - "(MenuItemIndex afterItem, MenuID firstHierMenuID, OptionBits options) -> (ItemCount outHierMenuCount)"}, + PyDoc_STR("(MenuItemIndex afterItem, MenuID firstHierMenuID, OptionBits options) -> (ItemCount outHierMenuCount)")}, #endif #if TARGET_API_MAC_CARBON {"UpdateStandardFontMenu", (PyCFunction)MenuObj_UpdateStandardFontMenu, 1, - "() -> (ItemCount outHierMenuCount)"}, + PyDoc_STR("() -> (ItemCount outHierMenuCount)")}, #endif #if TARGET_API_MAC_CARBON {"GetFontFamilyFromMenuSelection", (PyCFunction)MenuObj_GetFontFamilyFromMenuSelection, 1, - "(MenuItemIndex item) -> (FMFontFamily outFontFamily, FMFontStyle outStyle)"}, + PyDoc_STR("(MenuItemIndex item) -> (FMFontFamily outFontFamily, FMFontStyle outStyle)")}, #endif {"GetMenuID", (PyCFunction)MenuObj_GetMenuID, 1, - "() -> (MenuID _rv)"}, + PyDoc_STR("() -> (MenuID _rv)")}, {"GetMenuWidth", (PyCFunction)MenuObj_GetMenuWidth, 1, - "() -> (SInt16 _rv)"}, + PyDoc_STR("() -> (SInt16 _rv)")}, {"GetMenuHeight", (PyCFunction)MenuObj_GetMenuHeight, 1, - "() -> (SInt16 _rv)"}, + PyDoc_STR("() -> (SInt16 _rv)")}, {"SetMenuID", (PyCFunction)MenuObj_SetMenuID, 1, - "(MenuID menuID) -> None"}, + PyDoc_STR("(MenuID menuID) -> None")}, {"SetMenuWidth", (PyCFunction)MenuObj_SetMenuWidth, 1, - "(SInt16 width) -> None"}, + PyDoc_STR("(SInt16 width) -> None")}, {"SetMenuHeight", (PyCFunction)MenuObj_SetMenuHeight, 1, - "(SInt16 height) -> None"}, + PyDoc_STR("(SInt16 height) -> None")}, {"as_Resource", (PyCFunction)MenuObj_as_Resource, 1, - "() -> (Handle _rv)"}, + PyDoc_STR("() -> (Handle _rv)")}, {"AppendMenu", (PyCFunction)MenuObj_AppendMenu, 1, - "(Str255 data) -> None"}, + PyDoc_STR("(Str255 data) -> None")}, {"InsertMenu", (PyCFunction)MenuObj_InsertMenu, 1, - "(short beforeID) -> None"}, + PyDoc_STR("(short beforeID) -> None")}, {"InsertMenuItem", (PyCFunction)MenuObj_InsertMenuItem, 1, - "(Str255 itemString, short afterItem) -> None"}, + PyDoc_STR("(Str255 itemString, short afterItem) -> None")}, {"EnableMenuItem", (PyCFunction)MenuObj_EnableMenuItem, 1, - "(UInt16 item) -> None"}, + PyDoc_STR("(UInt16 item) -> None")}, {"CheckMenuItem", (PyCFunction)MenuObj_CheckMenuItem, 1, - "(short item, Boolean checked) -> None"}, + PyDoc_STR("(short item, Boolean checked) -> None")}, {NULL, NULL, 0} }; @@ -3942,155 +3942,155 @@ static PyMethodDef Menu_methods[] = { #if !TARGET_API_MAC_CARBON {"InitProcMenu", (PyCFunction)Menu_InitProcMenu, 1, - "(short resID) -> None"}, + PyDoc_STR("(short resID) -> None")}, #endif #if !TARGET_API_MAC_CARBON {"InitMenus", (PyCFunction)Menu_InitMenus, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif {"NewMenu", (PyCFunction)Menu_NewMenu, 1, - "(MenuID menuID, Str255 menuTitle) -> (MenuHandle _rv)"}, + PyDoc_STR("(MenuID menuID, Str255 menuTitle) -> (MenuHandle _rv)")}, {"MacGetMenu", (PyCFunction)Menu_MacGetMenu, 1, - "(short resourceID) -> (MenuHandle _rv)"}, + PyDoc_STR("(short resourceID) -> (MenuHandle _rv)")}, #if TARGET_API_MAC_CARBON {"CreateNewMenu", (PyCFunction)Menu_CreateNewMenu, 1, - "(MenuID inMenuID, MenuAttributes inMenuAttributes) -> (MenuHandle outMenuRef)"}, + PyDoc_STR("(MenuID inMenuID, MenuAttributes inMenuAttributes) -> (MenuHandle outMenuRef)")}, #endif {"MenuKey", (PyCFunction)Menu_MenuKey, 1, - "(CharParameter ch) -> (long _rv)"}, + PyDoc_STR("(CharParameter ch) -> (long _rv)")}, {"MenuSelect", (PyCFunction)Menu_MenuSelect, 1, - "(Point startPt) -> (long _rv)"}, + PyDoc_STR("(Point startPt) -> (long _rv)")}, {"MenuChoice", (PyCFunction)Menu_MenuChoice, 1, - "() -> (long _rv)"}, + PyDoc_STR("() -> (long _rv)")}, {"MenuEvent", (PyCFunction)Menu_MenuEvent, 1, - "(EventRecord inEvent) -> (UInt32 _rv)"}, + PyDoc_STR("(EventRecord inEvent) -> (UInt32 _rv)")}, {"GetMBarHeight", (PyCFunction)Menu_GetMBarHeight, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, {"MacDrawMenuBar", (PyCFunction)Menu_MacDrawMenuBar, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"InvalMenuBar", (PyCFunction)Menu_InvalMenuBar, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"HiliteMenu", (PyCFunction)Menu_HiliteMenu, 1, - "(MenuID menuID) -> None"}, + PyDoc_STR("(MenuID menuID) -> None")}, {"GetNewMBar", (PyCFunction)Menu_GetNewMBar, 1, - "(short menuBarID) -> (MenuBarHandle _rv)"}, + PyDoc_STR("(short menuBarID) -> (MenuBarHandle _rv)")}, {"GetMenuBar", (PyCFunction)Menu_GetMenuBar, 1, - "() -> (MenuBarHandle _rv)"}, + PyDoc_STR("() -> (MenuBarHandle _rv)")}, {"SetMenuBar", (PyCFunction)Menu_SetMenuBar, 1, - "(MenuBarHandle mbar) -> None"}, + PyDoc_STR("(MenuBarHandle mbar) -> None")}, #if TARGET_API_MAC_CARBON {"DuplicateMenuBar", (PyCFunction)Menu_DuplicateMenuBar, 1, - "(MenuBarHandle inMbar) -> (MenuBarHandle outMbar)"}, + PyDoc_STR("(MenuBarHandle inMbar) -> (MenuBarHandle outMbar)")}, #endif #if TARGET_API_MAC_CARBON {"DisposeMenuBar", (PyCFunction)Menu_DisposeMenuBar, 1, - "(MenuBarHandle inMbar) -> None"}, + PyDoc_STR("(MenuBarHandle inMbar) -> None")}, #endif {"GetMenuHandle", (PyCFunction)Menu_GetMenuHandle, 1, - "(MenuID menuID) -> (MenuHandle _rv)"}, + PyDoc_STR("(MenuID menuID) -> (MenuHandle _rv)")}, {"MacDeleteMenu", (PyCFunction)Menu_MacDeleteMenu, 1, - "(MenuID menuID) -> None"}, + PyDoc_STR("(MenuID menuID) -> None")}, {"ClearMenuBar", (PyCFunction)Menu_ClearMenuBar, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #if !TARGET_API_MAC_CARBON {"SetMenuFlash", (PyCFunction)Menu_SetMenuFlash, 1, - "(short count) -> None"}, + PyDoc_STR("(short count) -> None")}, #endif {"SetMenuFlashCount", (PyCFunction)Menu_SetMenuFlashCount, 1, - "(short count) -> None"}, + PyDoc_STR("(short count) -> None")}, {"FlashMenuBar", (PyCFunction)Menu_FlashMenuBar, 1, - "(MenuID menuID) -> None"}, + PyDoc_STR("(MenuID menuID) -> None")}, #if !TARGET_API_MAC_CARBON {"SystemEdit", (PyCFunction)Menu_SystemEdit, 1, - "(short editCmd) -> (Boolean _rv)"}, + PyDoc_STR("(short editCmd) -> (Boolean _rv)")}, #endif #if !TARGET_API_MAC_CARBON {"SystemMenu", (PyCFunction)Menu_SystemMenu, 1, - "(long menuResult) -> None"}, + PyDoc_STR("(long menuResult) -> None")}, #endif {"IsMenuBarVisible", (PyCFunction)Menu_IsMenuBarVisible, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, {"ShowMenuBar", (PyCFunction)Menu_ShowMenuBar, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"HideMenuBar", (PyCFunction)Menu_HideMenuBar, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #if TARGET_API_MAC_CARBON {"AcquireRootMenu", (PyCFunction)Menu_AcquireRootMenu, 1, - "() -> (MenuHandle _rv)"}, + PyDoc_STR("() -> (MenuHandle _rv)")}, #endif {"DeleteMCEntries", (PyCFunction)Menu_DeleteMCEntries, 1, - "(MenuID menuID, short menuItem) -> None"}, + PyDoc_STR("(MenuID menuID, short menuItem) -> None")}, {"InitContextualMenus", (PyCFunction)Menu_InitContextualMenus, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"IsShowContextualMenuClick", (PyCFunction)Menu_IsShowContextualMenuClick, 1, - "(EventRecord inEvent) -> (Boolean _rv)"}, + PyDoc_STR("(EventRecord inEvent) -> (Boolean _rv)")}, {"LMGetTheMenu", (PyCFunction)Menu_LMGetTheMenu, 1, - "() -> (SInt16 _rv)"}, + PyDoc_STR("() -> (SInt16 _rv)")}, #if !TARGET_API_MAC_CARBON {"OpenDeskAcc", (PyCFunction)Menu_OpenDeskAcc, 1, - "(Str255 name) -> None"}, + PyDoc_STR("(Str255 name) -> None")}, #endif {"as_Menu", (PyCFunction)Menu_as_Menu, 1, - "(Handle h) -> (MenuHandle _rv)"}, + PyDoc_STR("(Handle h) -> (MenuHandle _rv)")}, {"GetMenu", (PyCFunction)Menu_GetMenu, 1, - "(short resourceID) -> (MenuHandle _rv)"}, + PyDoc_STR("(short resourceID) -> (MenuHandle _rv)")}, {"DeleteMenu", (PyCFunction)Menu_DeleteMenu, 1, - "(short menuID) -> None"}, + PyDoc_STR("(short menuID) -> None")}, {"DrawMenuBar", (PyCFunction)Menu_DrawMenuBar, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #if TARGET_API_MAC_CARBON {"CountMenuItemsWithCommandID", (PyCFunction)Menu_CountMenuItemsWithCommandID, 1, - "(MenuHandle inMenu, MenuCommand inCommandID) -> (ItemCount _rv)"}, + PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> (ItemCount _rv)")}, #endif #if TARGET_API_MAC_CARBON {"GetIndMenuItemWithCommandID", (PyCFunction)Menu_GetIndMenuItemWithCommandID, 1, - "(MenuHandle inMenu, MenuCommand inCommandID, UInt32 inItemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)"}, + PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, UInt32 inItemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)")}, #endif #if TARGET_API_MAC_CARBON {"EnableMenuCommand", (PyCFunction)Menu_EnableMenuCommand, 1, - "(MenuHandle inMenu, MenuCommand inCommandID) -> None"}, + PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> None")}, #endif #if TARGET_API_MAC_CARBON {"DisableMenuCommand", (PyCFunction)Menu_DisableMenuCommand, 1, - "(MenuHandle inMenu, MenuCommand inCommandID) -> None"}, + PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> None")}, #endif #if TARGET_API_MAC_CARBON {"IsMenuCommandEnabled", (PyCFunction)Menu_IsMenuCommandEnabled, 1, - "(MenuHandle inMenu, MenuCommand inCommandID) -> (Boolean _rv)"}, + PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> (Boolean _rv)")}, #endif #if TARGET_API_MAC_CARBON {"SetMenuCommandMark", (PyCFunction)Menu_SetMenuCommandMark, 1, - "(MenuHandle inMenu, MenuCommand inCommandID, UniChar inMark) -> None"}, + PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, UniChar inMark) -> None")}, #endif #if TARGET_API_MAC_CARBON {"GetMenuCommandMark", (PyCFunction)Menu_GetMenuCommandMark, 1, - "(MenuHandle inMenu, MenuCommand inCommandID) -> (UniChar outMark)"}, + PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> (UniChar outMark)")}, #endif #if TARGET_API_MAC_CARBON {"GetMenuCommandPropertySize", (PyCFunction)Menu_GetMenuCommandPropertySize, 1, - "(MenuHandle inMenu, MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> (ByteCount outSize)"}, + PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> (ByteCount outSize)")}, #endif #if TARGET_API_MAC_CARBON {"RemoveMenuCommandProperty", (PyCFunction)Menu_RemoveMenuCommandProperty, 1, - "(MenuHandle inMenu, MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> None"}, + PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> None")}, #endif {NULL, NULL, 0} }; diff --git a/Mac/Modules/qd/_Qdmodule.c b/Mac/Modules/qd/_Qdmodule.c index f7956b8..1084031 100644 --- a/Mac/Modules/qd/_Qdmodule.c +++ b/Mac/Modules/qd/_Qdmodule.c @@ -470,9 +470,9 @@ static PyObject *BMObj_putdata(BitMapObject *_self, PyObject *_args) static PyMethodDef BMObj_methods[] = { {"getdata", (PyCFunction)BMObj_getdata, 1, - "(int start, int size) -> string. Return bytes from the bitmap"}, + PyDoc_STR("(int start, int size) -> string. Return bytes from the bitmap")}, {"putdata", (PyCFunction)BMObj_putdata, 1, - "(int start, string data). Store bytes into the bitmap"}, + PyDoc_STR("(int start, string data). Store bytes into the bitmap")}, {NULL, NULL, 0} }; @@ -6462,664 +6462,664 @@ static PyObject *Qd_RawBitMap(PyObject *_self, PyObject *_args) static PyMethodDef Qd_methods[] = { {"MacSetPort", (PyCFunction)Qd_MacSetPort, 1, - "(GrafPtr port) -> None"}, + PyDoc_STR("(GrafPtr port) -> None")}, {"GetPort", (PyCFunction)Qd_GetPort, 1, - "() -> (GrafPtr port)"}, + PyDoc_STR("() -> (GrafPtr port)")}, {"GrafDevice", (PyCFunction)Qd_GrafDevice, 1, - "(short device) -> None"}, + PyDoc_STR("(short device) -> None")}, {"SetPortBits", (PyCFunction)Qd_SetPortBits, 1, - "(BitMapPtr bm) -> None"}, + PyDoc_STR("(BitMapPtr bm) -> None")}, {"PortSize", (PyCFunction)Qd_PortSize, 1, - "(short width, short height) -> None"}, + PyDoc_STR("(short width, short height) -> None")}, {"MovePortTo", (PyCFunction)Qd_MovePortTo, 1, - "(short leftGlobal, short topGlobal) -> None"}, + PyDoc_STR("(short leftGlobal, short topGlobal) -> None")}, {"SetOrigin", (PyCFunction)Qd_SetOrigin, 1, - "(short h, short v) -> None"}, + PyDoc_STR("(short h, short v) -> None")}, {"SetClip", (PyCFunction)Qd_SetClip, 1, - "(RgnHandle rgn) -> None"}, + PyDoc_STR("(RgnHandle rgn) -> None")}, {"GetClip", (PyCFunction)Qd_GetClip, 1, - "(RgnHandle rgn) -> None"}, + PyDoc_STR("(RgnHandle rgn) -> None")}, {"ClipRect", (PyCFunction)Qd_ClipRect, 1, - "(Rect r) -> None"}, + PyDoc_STR("(Rect r) -> None")}, {"BackPat", (PyCFunction)Qd_BackPat, 1, - "(Pattern pat) -> None"}, + PyDoc_STR("(Pattern pat) -> None")}, {"InitCursor", (PyCFunction)Qd_InitCursor, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"MacSetCursor", (PyCFunction)Qd_MacSetCursor, 1, - "(Cursor crsr) -> None"}, + PyDoc_STR("(Cursor crsr) -> None")}, {"HideCursor", (PyCFunction)Qd_HideCursor, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"MacShowCursor", (PyCFunction)Qd_MacShowCursor, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"ObscureCursor", (PyCFunction)Qd_ObscureCursor, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"HidePen", (PyCFunction)Qd_HidePen, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"ShowPen", (PyCFunction)Qd_ShowPen, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"GetPen", (PyCFunction)Qd_GetPen, 1, - "() -> (Point pt)"}, + PyDoc_STR("() -> (Point pt)")}, {"GetPenState", (PyCFunction)Qd_GetPenState, 1, - "() -> (PenState pnState)"}, + PyDoc_STR("() -> (PenState pnState)")}, {"SetPenState", (PyCFunction)Qd_SetPenState, 1, - "(PenState pnState) -> None"}, + PyDoc_STR("(PenState pnState) -> None")}, {"PenSize", (PyCFunction)Qd_PenSize, 1, - "(short width, short height) -> None"}, + PyDoc_STR("(short width, short height) -> None")}, {"PenMode", (PyCFunction)Qd_PenMode, 1, - "(short mode) -> None"}, + PyDoc_STR("(short mode) -> None")}, {"PenPat", (PyCFunction)Qd_PenPat, 1, - "(Pattern pat) -> None"}, + PyDoc_STR("(Pattern pat) -> None")}, {"PenNormal", (PyCFunction)Qd_PenNormal, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"MoveTo", (PyCFunction)Qd_MoveTo, 1, - "(short h, short v) -> None"}, + PyDoc_STR("(short h, short v) -> None")}, {"Move", (PyCFunction)Qd_Move, 1, - "(short dh, short dv) -> None"}, + PyDoc_STR("(short dh, short dv) -> None")}, {"MacLineTo", (PyCFunction)Qd_MacLineTo, 1, - "(short h, short v) -> None"}, + PyDoc_STR("(short h, short v) -> None")}, {"Line", (PyCFunction)Qd_Line, 1, - "(short dh, short dv) -> None"}, + PyDoc_STR("(short dh, short dv) -> None")}, {"ForeColor", (PyCFunction)Qd_ForeColor, 1, - "(long color) -> None"}, + PyDoc_STR("(long color) -> None")}, {"BackColor", (PyCFunction)Qd_BackColor, 1, - "(long color) -> None"}, + PyDoc_STR("(long color) -> None")}, {"ColorBit", (PyCFunction)Qd_ColorBit, 1, - "(short whichBit) -> None"}, + PyDoc_STR("(short whichBit) -> None")}, {"MacSetRect", (PyCFunction)Qd_MacSetRect, 1, - "(short left, short top, short right, short bottom) -> (Rect r)"}, + PyDoc_STR("(short left, short top, short right, short bottom) -> (Rect r)")}, {"MacOffsetRect", (PyCFunction)Qd_MacOffsetRect, 1, - "(Rect r, short dh, short dv) -> (Rect r)"}, + PyDoc_STR("(Rect r, short dh, short dv) -> (Rect r)")}, {"MacInsetRect", (PyCFunction)Qd_MacInsetRect, 1, - "(Rect r, short dh, short dv) -> (Rect r)"}, + PyDoc_STR("(Rect r, short dh, short dv) -> (Rect r)")}, {"SectRect", (PyCFunction)Qd_SectRect, 1, - "(Rect src1, Rect src2) -> (Boolean _rv, Rect dstRect)"}, + PyDoc_STR("(Rect src1, Rect src2) -> (Boolean _rv, Rect dstRect)")}, {"MacUnionRect", (PyCFunction)Qd_MacUnionRect, 1, - "(Rect src1, Rect src2) -> (Rect dstRect)"}, + PyDoc_STR("(Rect src1, Rect src2) -> (Rect dstRect)")}, {"MacEqualRect", (PyCFunction)Qd_MacEqualRect, 1, - "(Rect rect1, Rect rect2) -> (Boolean _rv)"}, + PyDoc_STR("(Rect rect1, Rect rect2) -> (Boolean _rv)")}, {"EmptyRect", (PyCFunction)Qd_EmptyRect, 1, - "(Rect r) -> (Boolean _rv)"}, + PyDoc_STR("(Rect r) -> (Boolean _rv)")}, {"MacFrameRect", (PyCFunction)Qd_MacFrameRect, 1, - "(Rect r) -> None"}, + PyDoc_STR("(Rect r) -> None")}, {"PaintRect", (PyCFunction)Qd_PaintRect, 1, - "(Rect r) -> None"}, + PyDoc_STR("(Rect r) -> None")}, {"EraseRect", (PyCFunction)Qd_EraseRect, 1, - "(Rect r) -> None"}, + PyDoc_STR("(Rect r) -> None")}, {"MacInvertRect", (PyCFunction)Qd_MacInvertRect, 1, - "(Rect r) -> None"}, + PyDoc_STR("(Rect r) -> None")}, {"MacFillRect", (PyCFunction)Qd_MacFillRect, 1, - "(Rect r, Pattern pat) -> None"}, + PyDoc_STR("(Rect r, Pattern pat) -> None")}, {"FrameOval", (PyCFunction)Qd_FrameOval, 1, - "(Rect r) -> None"}, + PyDoc_STR("(Rect r) -> None")}, {"PaintOval", (PyCFunction)Qd_PaintOval, 1, - "(Rect r) -> None"}, + PyDoc_STR("(Rect r) -> None")}, {"EraseOval", (PyCFunction)Qd_EraseOval, 1, - "(Rect r) -> None"}, + PyDoc_STR("(Rect r) -> None")}, {"InvertOval", (PyCFunction)Qd_InvertOval, 1, - "(Rect r) -> None"}, + PyDoc_STR("(Rect r) -> None")}, {"FillOval", (PyCFunction)Qd_FillOval, 1, - "(Rect r, Pattern pat) -> None"}, + PyDoc_STR("(Rect r, Pattern pat) -> None")}, {"FrameRoundRect", (PyCFunction)Qd_FrameRoundRect, 1, - "(Rect r, short ovalWidth, short ovalHeight) -> None"}, + PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight) -> None")}, {"PaintRoundRect", (PyCFunction)Qd_PaintRoundRect, 1, - "(Rect r, short ovalWidth, short ovalHeight) -> None"}, + PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight) -> None")}, {"EraseRoundRect", (PyCFunction)Qd_EraseRoundRect, 1, - "(Rect r, short ovalWidth, short ovalHeight) -> None"}, + PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight) -> None")}, {"InvertRoundRect", (PyCFunction)Qd_InvertRoundRect, 1, - "(Rect r, short ovalWidth, short ovalHeight) -> None"}, + PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight) -> None")}, {"FillRoundRect", (PyCFunction)Qd_FillRoundRect, 1, - "(Rect r, short ovalWidth, short ovalHeight, Pattern pat) -> None"}, + PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight, Pattern pat) -> None")}, {"FrameArc", (PyCFunction)Qd_FrameArc, 1, - "(Rect r, short startAngle, short arcAngle) -> None"}, + PyDoc_STR("(Rect r, short startAngle, short arcAngle) -> None")}, {"PaintArc", (PyCFunction)Qd_PaintArc, 1, - "(Rect r, short startAngle, short arcAngle) -> None"}, + PyDoc_STR("(Rect r, short startAngle, short arcAngle) -> None")}, {"EraseArc", (PyCFunction)Qd_EraseArc, 1, - "(Rect r, short startAngle, short arcAngle) -> None"}, + PyDoc_STR("(Rect r, short startAngle, short arcAngle) -> None")}, {"InvertArc", (PyCFunction)Qd_InvertArc, 1, - "(Rect r, short startAngle, short arcAngle) -> None"}, + PyDoc_STR("(Rect r, short startAngle, short arcAngle) -> None")}, {"FillArc", (PyCFunction)Qd_FillArc, 1, - "(Rect r, short startAngle, short arcAngle, Pattern pat) -> None"}, + PyDoc_STR("(Rect r, short startAngle, short arcAngle, Pattern pat) -> None")}, {"NewRgn", (PyCFunction)Qd_NewRgn, 1, - "() -> (RgnHandle _rv)"}, + PyDoc_STR("() -> (RgnHandle _rv)")}, {"OpenRgn", (PyCFunction)Qd_OpenRgn, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CloseRgn", (PyCFunction)Qd_CloseRgn, 1, - "(RgnHandle dstRgn) -> None"}, + PyDoc_STR("(RgnHandle dstRgn) -> None")}, {"BitMapToRegion", (PyCFunction)Qd_BitMapToRegion, 1, - "(RgnHandle region, BitMapPtr bMap) -> None"}, + PyDoc_STR("(RgnHandle region, BitMapPtr bMap) -> None")}, #if TARGET_API_MAC_CARBON {"RgnToHandle", (PyCFunction)Qd_RgnToHandle, 1, - "(RgnHandle region, Handle flattenedRgnDataHdl) -> None"}, + PyDoc_STR("(RgnHandle region, Handle flattenedRgnDataHdl) -> None")}, #endif {"DisposeRgn", (PyCFunction)Qd_DisposeRgn, 1, - "(RgnHandle rgn) -> None"}, + PyDoc_STR("(RgnHandle rgn) -> None")}, {"MacCopyRgn", (PyCFunction)Qd_MacCopyRgn, 1, - "(RgnHandle srcRgn, RgnHandle dstRgn) -> None"}, + PyDoc_STR("(RgnHandle srcRgn, RgnHandle dstRgn) -> None")}, {"SetEmptyRgn", (PyCFunction)Qd_SetEmptyRgn, 1, - "(RgnHandle rgn) -> None"}, + PyDoc_STR("(RgnHandle rgn) -> None")}, {"MacSetRectRgn", (PyCFunction)Qd_MacSetRectRgn, 1, - "(RgnHandle rgn, short left, short top, short right, short bottom) -> None"}, + PyDoc_STR("(RgnHandle rgn, short left, short top, short right, short bottom) -> None")}, {"RectRgn", (PyCFunction)Qd_RectRgn, 1, - "(RgnHandle rgn, Rect r) -> None"}, + PyDoc_STR("(RgnHandle rgn, Rect r) -> None")}, {"MacOffsetRgn", (PyCFunction)Qd_MacOffsetRgn, 1, - "(RgnHandle rgn, short dh, short dv) -> None"}, + PyDoc_STR("(RgnHandle rgn, short dh, short dv) -> None")}, {"InsetRgn", (PyCFunction)Qd_InsetRgn, 1, - "(RgnHandle rgn, short dh, short dv) -> None"}, + PyDoc_STR("(RgnHandle rgn, short dh, short dv) -> None")}, {"SectRgn", (PyCFunction)Qd_SectRgn, 1, - "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"}, + PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")}, {"MacUnionRgn", (PyCFunction)Qd_MacUnionRgn, 1, - "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"}, + PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")}, {"DiffRgn", (PyCFunction)Qd_DiffRgn, 1, - "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"}, + PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")}, {"MacXorRgn", (PyCFunction)Qd_MacXorRgn, 1, - "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"}, + PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")}, {"RectInRgn", (PyCFunction)Qd_RectInRgn, 1, - "(Rect r, RgnHandle rgn) -> (Boolean _rv)"}, + PyDoc_STR("(Rect r, RgnHandle rgn) -> (Boolean _rv)")}, {"MacEqualRgn", (PyCFunction)Qd_MacEqualRgn, 1, - "(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)"}, + PyDoc_STR("(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)")}, {"EmptyRgn", (PyCFunction)Qd_EmptyRgn, 1, - "(RgnHandle rgn) -> (Boolean _rv)"}, + PyDoc_STR("(RgnHandle rgn) -> (Boolean _rv)")}, {"MacFrameRgn", (PyCFunction)Qd_MacFrameRgn, 1, - "(RgnHandle rgn) -> None"}, + PyDoc_STR("(RgnHandle rgn) -> None")}, {"MacPaintRgn", (PyCFunction)Qd_MacPaintRgn, 1, - "(RgnHandle rgn) -> None"}, + PyDoc_STR("(RgnHandle rgn) -> None")}, {"EraseRgn", (PyCFunction)Qd_EraseRgn, 1, - "(RgnHandle rgn) -> None"}, + PyDoc_STR("(RgnHandle rgn) -> None")}, {"MacInvertRgn", (PyCFunction)Qd_MacInvertRgn, 1, - "(RgnHandle rgn) -> None"}, + PyDoc_STR("(RgnHandle rgn) -> None")}, {"MacFillRgn", (PyCFunction)Qd_MacFillRgn, 1, - "(RgnHandle rgn, Pattern pat) -> None"}, + PyDoc_STR("(RgnHandle rgn, Pattern pat) -> None")}, {"ScrollRect", (PyCFunction)Qd_ScrollRect, 1, - "(Rect r, short dh, short dv, RgnHandle updateRgn) -> None"}, + PyDoc_STR("(Rect r, short dh, short dv, RgnHandle updateRgn) -> None")}, {"CopyBits", (PyCFunction)Qd_CopyBits, 1, - "(BitMapPtr srcBits, BitMapPtr dstBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"}, + PyDoc_STR("(BitMapPtr srcBits, BitMapPtr dstBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None")}, {"CopyMask", (PyCFunction)Qd_CopyMask, 1, - "(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect) -> None"}, + PyDoc_STR("(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect) -> None")}, {"OpenPicture", (PyCFunction)Qd_OpenPicture, 1, - "(Rect picFrame) -> (PicHandle _rv)"}, + PyDoc_STR("(Rect picFrame) -> (PicHandle _rv)")}, {"PicComment", (PyCFunction)Qd_PicComment, 1, - "(short kind, short dataSize, Handle dataHandle) -> None"}, + PyDoc_STR("(short kind, short dataSize, Handle dataHandle) -> None")}, {"ClosePicture", (PyCFunction)Qd_ClosePicture, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"DrawPicture", (PyCFunction)Qd_DrawPicture, 1, - "(PicHandle myPicture, Rect dstRect) -> None"}, + PyDoc_STR("(PicHandle myPicture, Rect dstRect) -> None")}, {"KillPicture", (PyCFunction)Qd_KillPicture, 1, - "(PicHandle myPicture) -> None"}, + PyDoc_STR("(PicHandle myPicture) -> None")}, {"OpenPoly", (PyCFunction)Qd_OpenPoly, 1, - "() -> (PolyHandle _rv)"}, + PyDoc_STR("() -> (PolyHandle _rv)")}, {"ClosePoly", (PyCFunction)Qd_ClosePoly, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"KillPoly", (PyCFunction)Qd_KillPoly, 1, - "(PolyHandle poly) -> None"}, + PyDoc_STR("(PolyHandle poly) -> None")}, {"OffsetPoly", (PyCFunction)Qd_OffsetPoly, 1, - "(PolyHandle poly, short dh, short dv) -> None"}, + PyDoc_STR("(PolyHandle poly, short dh, short dv) -> None")}, {"FramePoly", (PyCFunction)Qd_FramePoly, 1, - "(PolyHandle poly) -> None"}, + PyDoc_STR("(PolyHandle poly) -> None")}, {"PaintPoly", (PyCFunction)Qd_PaintPoly, 1, - "(PolyHandle poly) -> None"}, + PyDoc_STR("(PolyHandle poly) -> None")}, {"ErasePoly", (PyCFunction)Qd_ErasePoly, 1, - "(PolyHandle poly) -> None"}, + PyDoc_STR("(PolyHandle poly) -> None")}, {"InvertPoly", (PyCFunction)Qd_InvertPoly, 1, - "(PolyHandle poly) -> None"}, + PyDoc_STR("(PolyHandle poly) -> None")}, {"FillPoly", (PyCFunction)Qd_FillPoly, 1, - "(PolyHandle poly, Pattern pat) -> None"}, + PyDoc_STR("(PolyHandle poly, Pattern pat) -> None")}, {"SetPt", (PyCFunction)Qd_SetPt, 1, - "(short h, short v) -> (Point pt)"}, + PyDoc_STR("(short h, short v) -> (Point pt)")}, {"LocalToGlobal", (PyCFunction)Qd_LocalToGlobal, 1, - "(Point pt) -> (Point pt)"}, + PyDoc_STR("(Point pt) -> (Point pt)")}, {"GlobalToLocal", (PyCFunction)Qd_GlobalToLocal, 1, - "(Point pt) -> (Point pt)"}, + PyDoc_STR("(Point pt) -> (Point pt)")}, {"Random", (PyCFunction)Qd_Random, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, {"MacGetPixel", (PyCFunction)Qd_MacGetPixel, 1, - "(short h, short v) -> (Boolean _rv)"}, + PyDoc_STR("(short h, short v) -> (Boolean _rv)")}, {"ScalePt", (PyCFunction)Qd_ScalePt, 1, - "(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)"}, + PyDoc_STR("(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)")}, {"MapPt", (PyCFunction)Qd_MapPt, 1, - "(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)"}, + PyDoc_STR("(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)")}, {"MapRect", (PyCFunction)Qd_MapRect, 1, - "(Rect r, Rect srcRect, Rect dstRect) -> (Rect r)"}, + PyDoc_STR("(Rect r, Rect srcRect, Rect dstRect) -> (Rect r)")}, {"MapRgn", (PyCFunction)Qd_MapRgn, 1, - "(RgnHandle rgn, Rect srcRect, Rect dstRect) -> None"}, + PyDoc_STR("(RgnHandle rgn, Rect srcRect, Rect dstRect) -> None")}, {"MapPoly", (PyCFunction)Qd_MapPoly, 1, - "(PolyHandle poly, Rect srcRect, Rect dstRect) -> None"}, + PyDoc_STR("(PolyHandle poly, Rect srcRect, Rect dstRect) -> None")}, {"StdBits", (PyCFunction)Qd_StdBits, 1, - "(BitMapPtr srcBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"}, + PyDoc_STR("(BitMapPtr srcBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None")}, {"AddPt", (PyCFunction)Qd_AddPt, 1, - "(Point src, Point dst) -> (Point dst)"}, + PyDoc_STR("(Point src, Point dst) -> (Point dst)")}, {"EqualPt", (PyCFunction)Qd_EqualPt, 1, - "(Point pt1, Point pt2) -> (Boolean _rv)"}, + PyDoc_STR("(Point pt1, Point pt2) -> (Boolean _rv)")}, {"MacPtInRect", (PyCFunction)Qd_MacPtInRect, 1, - "(Point pt, Rect r) -> (Boolean _rv)"}, + PyDoc_STR("(Point pt, Rect r) -> (Boolean _rv)")}, {"Pt2Rect", (PyCFunction)Qd_Pt2Rect, 1, - "(Point pt1, Point pt2) -> (Rect dstRect)"}, + PyDoc_STR("(Point pt1, Point pt2) -> (Rect dstRect)")}, {"PtToAngle", (PyCFunction)Qd_PtToAngle, 1, - "(Rect r, Point pt) -> (short angle)"}, + PyDoc_STR("(Rect r, Point pt) -> (short angle)")}, {"SubPt", (PyCFunction)Qd_SubPt, 1, - "(Point src, Point dst) -> (Point dst)"}, + PyDoc_STR("(Point src, Point dst) -> (Point dst)")}, {"PtInRgn", (PyCFunction)Qd_PtInRgn, 1, - "(Point pt, RgnHandle rgn) -> (Boolean _rv)"}, + PyDoc_STR("(Point pt, RgnHandle rgn) -> (Boolean _rv)")}, {"NewPixMap", (PyCFunction)Qd_NewPixMap, 1, - "() -> (PixMapHandle _rv)"}, + PyDoc_STR("() -> (PixMapHandle _rv)")}, {"DisposePixMap", (PyCFunction)Qd_DisposePixMap, 1, - "(PixMapHandle pm) -> None"}, + PyDoc_STR("(PixMapHandle pm) -> None")}, {"CopyPixMap", (PyCFunction)Qd_CopyPixMap, 1, - "(PixMapHandle srcPM, PixMapHandle dstPM) -> None"}, + PyDoc_STR("(PixMapHandle srcPM, PixMapHandle dstPM) -> None")}, {"NewPixPat", (PyCFunction)Qd_NewPixPat, 1, - "() -> (PixPatHandle _rv)"}, + PyDoc_STR("() -> (PixPatHandle _rv)")}, {"DisposePixPat", (PyCFunction)Qd_DisposePixPat, 1, - "(PixPatHandle pp) -> None"}, + PyDoc_STR("(PixPatHandle pp) -> None")}, {"CopyPixPat", (PyCFunction)Qd_CopyPixPat, 1, - "(PixPatHandle srcPP, PixPatHandle dstPP) -> None"}, + PyDoc_STR("(PixPatHandle srcPP, PixPatHandle dstPP) -> None")}, {"PenPixPat", (PyCFunction)Qd_PenPixPat, 1, - "(PixPatHandle pp) -> None"}, + PyDoc_STR("(PixPatHandle pp) -> None")}, {"BackPixPat", (PyCFunction)Qd_BackPixPat, 1, - "(PixPatHandle pp) -> None"}, + PyDoc_STR("(PixPatHandle pp) -> None")}, {"GetPixPat", (PyCFunction)Qd_GetPixPat, 1, - "(short patID) -> (PixPatHandle _rv)"}, + PyDoc_STR("(short patID) -> (PixPatHandle _rv)")}, {"MakeRGBPat", (PyCFunction)Qd_MakeRGBPat, 1, - "(PixPatHandle pp, RGBColor myColor) -> None"}, + PyDoc_STR("(PixPatHandle pp, RGBColor myColor) -> None")}, {"FillCRect", (PyCFunction)Qd_FillCRect, 1, - "(Rect r, PixPatHandle pp) -> None"}, + PyDoc_STR("(Rect r, PixPatHandle pp) -> None")}, {"FillCOval", (PyCFunction)Qd_FillCOval, 1, - "(Rect r, PixPatHandle pp) -> None"}, + PyDoc_STR("(Rect r, PixPatHandle pp) -> None")}, {"FillCRoundRect", (PyCFunction)Qd_FillCRoundRect, 1, - "(Rect r, short ovalWidth, short ovalHeight, PixPatHandle pp) -> None"}, + PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight, PixPatHandle pp) -> None")}, {"FillCArc", (PyCFunction)Qd_FillCArc, 1, - "(Rect r, short startAngle, short arcAngle, PixPatHandle pp) -> None"}, + PyDoc_STR("(Rect r, short startAngle, short arcAngle, PixPatHandle pp) -> None")}, {"FillCRgn", (PyCFunction)Qd_FillCRgn, 1, - "(RgnHandle rgn, PixPatHandle pp) -> None"}, + PyDoc_STR("(RgnHandle rgn, PixPatHandle pp) -> None")}, {"FillCPoly", (PyCFunction)Qd_FillCPoly, 1, - "(PolyHandle poly, PixPatHandle pp) -> None"}, + PyDoc_STR("(PolyHandle poly, PixPatHandle pp) -> None")}, {"RGBForeColor", (PyCFunction)Qd_RGBForeColor, 1, - "(RGBColor color) -> None"}, + PyDoc_STR("(RGBColor color) -> None")}, {"RGBBackColor", (PyCFunction)Qd_RGBBackColor, 1, - "(RGBColor color) -> None"}, + PyDoc_STR("(RGBColor color) -> None")}, {"SetCPixel", (PyCFunction)Qd_SetCPixel, 1, - "(short h, short v, RGBColor cPix) -> None"}, + PyDoc_STR("(short h, short v, RGBColor cPix) -> None")}, {"SetPortPix", (PyCFunction)Qd_SetPortPix, 1, - "(PixMapHandle pm) -> None"}, + PyDoc_STR("(PixMapHandle pm) -> None")}, {"GetCPixel", (PyCFunction)Qd_GetCPixel, 1, - "(short h, short v) -> (RGBColor cPix)"}, + PyDoc_STR("(short h, short v) -> (RGBColor cPix)")}, {"GetForeColor", (PyCFunction)Qd_GetForeColor, 1, - "() -> (RGBColor color)"}, + PyDoc_STR("() -> (RGBColor color)")}, {"GetBackColor", (PyCFunction)Qd_GetBackColor, 1, - "() -> (RGBColor color)"}, + PyDoc_STR("() -> (RGBColor color)")}, {"OpColor", (PyCFunction)Qd_OpColor, 1, - "(RGBColor color) -> None"}, + PyDoc_STR("(RGBColor color) -> None")}, {"HiliteColor", (PyCFunction)Qd_HiliteColor, 1, - "(RGBColor color) -> None"}, + PyDoc_STR("(RGBColor color) -> None")}, {"DisposeCTable", (PyCFunction)Qd_DisposeCTable, 1, - "(CTabHandle cTable) -> None"}, + PyDoc_STR("(CTabHandle cTable) -> None")}, {"GetCTable", (PyCFunction)Qd_GetCTable, 1, - "(short ctID) -> (CTabHandle _rv)"}, + PyDoc_STR("(short ctID) -> (CTabHandle _rv)")}, {"GetCCursor", (PyCFunction)Qd_GetCCursor, 1, - "(short crsrID) -> (CCrsrHandle _rv)"}, + PyDoc_STR("(short crsrID) -> (CCrsrHandle _rv)")}, {"SetCCursor", (PyCFunction)Qd_SetCCursor, 1, - "(CCrsrHandle cCrsr) -> None"}, + PyDoc_STR("(CCrsrHandle cCrsr) -> None")}, {"AllocCursor", (PyCFunction)Qd_AllocCursor, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"DisposeCCursor", (PyCFunction)Qd_DisposeCCursor, 1, - "(CCrsrHandle cCrsr) -> None"}, + PyDoc_STR("(CCrsrHandle cCrsr) -> None")}, {"GetMaxDevice", (PyCFunction)Qd_GetMaxDevice, 1, - "(Rect globalRect) -> (GDHandle _rv)"}, + PyDoc_STR("(Rect globalRect) -> (GDHandle _rv)")}, {"GetCTSeed", (PyCFunction)Qd_GetCTSeed, 1, - "() -> (long _rv)"}, + PyDoc_STR("() -> (long _rv)")}, {"GetDeviceList", (PyCFunction)Qd_GetDeviceList, 1, - "() -> (GDHandle _rv)"}, + PyDoc_STR("() -> (GDHandle _rv)")}, {"GetMainDevice", (PyCFunction)Qd_GetMainDevice, 1, - "() -> (GDHandle _rv)"}, + PyDoc_STR("() -> (GDHandle _rv)")}, {"GetNextDevice", (PyCFunction)Qd_GetNextDevice, 1, - "(GDHandle curDevice) -> (GDHandle _rv)"}, + PyDoc_STR("(GDHandle curDevice) -> (GDHandle _rv)")}, {"TestDeviceAttribute", (PyCFunction)Qd_TestDeviceAttribute, 1, - "(GDHandle gdh, short attribute) -> (Boolean _rv)"}, + PyDoc_STR("(GDHandle gdh, short attribute) -> (Boolean _rv)")}, {"SetDeviceAttribute", (PyCFunction)Qd_SetDeviceAttribute, 1, - "(GDHandle gdh, short attribute, Boolean value) -> None"}, + PyDoc_STR("(GDHandle gdh, short attribute, Boolean value) -> None")}, {"InitGDevice", (PyCFunction)Qd_InitGDevice, 1, - "(short qdRefNum, long mode, GDHandle gdh) -> None"}, + PyDoc_STR("(short qdRefNum, long mode, GDHandle gdh) -> None")}, {"NewGDevice", (PyCFunction)Qd_NewGDevice, 1, - "(short refNum, long mode) -> (GDHandle _rv)"}, + PyDoc_STR("(short refNum, long mode) -> (GDHandle _rv)")}, {"DisposeGDevice", (PyCFunction)Qd_DisposeGDevice, 1, - "(GDHandle gdh) -> None"}, + PyDoc_STR("(GDHandle gdh) -> None")}, {"SetGDevice", (PyCFunction)Qd_SetGDevice, 1, - "(GDHandle gd) -> None"}, + PyDoc_STR("(GDHandle gd) -> None")}, {"GetGDevice", (PyCFunction)Qd_GetGDevice, 1, - "() -> (GDHandle _rv)"}, + PyDoc_STR("() -> (GDHandle _rv)")}, {"Color2Index", (PyCFunction)Qd_Color2Index, 1, - "(RGBColor myColor) -> (long _rv)"}, + PyDoc_STR("(RGBColor myColor) -> (long _rv)")}, {"Index2Color", (PyCFunction)Qd_Index2Color, 1, - "(long index) -> (RGBColor aColor)"}, + PyDoc_STR("(long index) -> (RGBColor aColor)")}, {"InvertColor", (PyCFunction)Qd_InvertColor, 1, - "() -> (RGBColor myColor)"}, + PyDoc_STR("() -> (RGBColor myColor)")}, {"RealColor", (PyCFunction)Qd_RealColor, 1, - "(RGBColor color) -> (Boolean _rv)"}, + PyDoc_STR("(RGBColor color) -> (Boolean _rv)")}, {"GetSubTable", (PyCFunction)Qd_GetSubTable, 1, - "(CTabHandle myColors, short iTabRes, CTabHandle targetTbl) -> None"}, + PyDoc_STR("(CTabHandle myColors, short iTabRes, CTabHandle targetTbl) -> None")}, {"MakeITable", (PyCFunction)Qd_MakeITable, 1, - "(CTabHandle cTabH, ITabHandle iTabH, short res) -> None"}, + PyDoc_STR("(CTabHandle cTabH, ITabHandle iTabH, short res) -> None")}, {"SetClientID", (PyCFunction)Qd_SetClientID, 1, - "(short id) -> None"}, + PyDoc_STR("(short id) -> None")}, {"ProtectEntry", (PyCFunction)Qd_ProtectEntry, 1, - "(short index, Boolean protect) -> None"}, + PyDoc_STR("(short index, Boolean protect) -> None")}, {"ReserveEntry", (PyCFunction)Qd_ReserveEntry, 1, - "(short index, Boolean reserve) -> None"}, + PyDoc_STR("(short index, Boolean reserve) -> None")}, {"QDError", (PyCFunction)Qd_QDError, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, {"CopyDeepMask", (PyCFunction)Qd_CopyDeepMask, 1, - "(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"}, + PyDoc_STR("(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None")}, {"GetPattern", (PyCFunction)Qd_GetPattern, 1, - "(short patternID) -> (PatHandle _rv)"}, + PyDoc_STR("(short patternID) -> (PatHandle _rv)")}, {"MacGetCursor", (PyCFunction)Qd_MacGetCursor, 1, - "(short cursorID) -> (CursHandle _rv)"}, + PyDoc_STR("(short cursorID) -> (CursHandle _rv)")}, {"GetPicture", (PyCFunction)Qd_GetPicture, 1, - "(short pictureID) -> (PicHandle _rv)"}, + PyDoc_STR("(short pictureID) -> (PicHandle _rv)")}, {"DeltaPoint", (PyCFunction)Qd_DeltaPoint, 1, - "(Point ptA, Point ptB) -> (long _rv)"}, + PyDoc_STR("(Point ptA, Point ptB) -> (long _rv)")}, {"ShieldCursor", (PyCFunction)Qd_ShieldCursor, 1, - "(Rect shieldRect, Point offsetPt) -> None"}, + PyDoc_STR("(Rect shieldRect, Point offsetPt) -> None")}, {"ScreenRes", (PyCFunction)Qd_ScreenRes, 1, - "() -> (short scrnHRes, short scrnVRes)"}, + PyDoc_STR("() -> (short scrnHRes, short scrnVRes)")}, {"GetIndPattern", (PyCFunction)Qd_GetIndPattern, 1, - "(short patternListID, short index) -> (Pattern thePat)"}, + PyDoc_STR("(short patternListID, short index) -> (Pattern thePat)")}, {"SlopeFromAngle", (PyCFunction)Qd_SlopeFromAngle, 1, - "(short angle) -> (Fixed _rv)"}, + PyDoc_STR("(short angle) -> (Fixed _rv)")}, {"AngleFromSlope", (PyCFunction)Qd_AngleFromSlope, 1, - "(Fixed slope) -> (short _rv)"}, + PyDoc_STR("(Fixed slope) -> (short _rv)")}, #if TARGET_API_MAC_CARBON {"IsValidPort", (PyCFunction)Qd_IsValidPort, 1, - "(CGrafPtr port) -> (Boolean _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")}, #endif {"GetPortPixMap", (PyCFunction)Qd_GetPortPixMap, 1, - "(CGrafPtr port) -> (PixMapHandle _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (PixMapHandle _rv)")}, {"GetPortBitMapForCopyBits", (PyCFunction)Qd_GetPortBitMapForCopyBits, 1, - "(CGrafPtr port) -> (const BitMap * _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (const BitMap * _rv)")}, {"GetPortBounds", (PyCFunction)Qd_GetPortBounds, 1, - "(CGrafPtr port) -> (Rect rect)"}, + PyDoc_STR("(CGrafPtr port) -> (Rect rect)")}, {"GetPortForeColor", (PyCFunction)Qd_GetPortForeColor, 1, - "(CGrafPtr port) -> (RGBColor foreColor)"}, + PyDoc_STR("(CGrafPtr port) -> (RGBColor foreColor)")}, {"GetPortBackColor", (PyCFunction)Qd_GetPortBackColor, 1, - "(CGrafPtr port) -> (RGBColor backColor)"}, + PyDoc_STR("(CGrafPtr port) -> (RGBColor backColor)")}, {"GetPortOpColor", (PyCFunction)Qd_GetPortOpColor, 1, - "(CGrafPtr port) -> (RGBColor opColor)"}, + PyDoc_STR("(CGrafPtr port) -> (RGBColor opColor)")}, {"GetPortHiliteColor", (PyCFunction)Qd_GetPortHiliteColor, 1, - "(CGrafPtr port) -> (RGBColor hiliteColor)"}, + PyDoc_STR("(CGrafPtr port) -> (RGBColor hiliteColor)")}, {"GetPortTextFont", (PyCFunction)Qd_GetPortTextFont, 1, - "(CGrafPtr port) -> (short _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (short _rv)")}, {"GetPortTextFace", (PyCFunction)Qd_GetPortTextFace, 1, - "(CGrafPtr port) -> (Style _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (Style _rv)")}, {"GetPortTextMode", (PyCFunction)Qd_GetPortTextMode, 1, - "(CGrafPtr port) -> (short _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (short _rv)")}, {"GetPortTextSize", (PyCFunction)Qd_GetPortTextSize, 1, - "(CGrafPtr port) -> (short _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (short _rv)")}, {"GetPortChExtra", (PyCFunction)Qd_GetPortChExtra, 1, - "(CGrafPtr port) -> (short _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (short _rv)")}, {"GetPortFracHPenLocation", (PyCFunction)Qd_GetPortFracHPenLocation, 1, - "(CGrafPtr port) -> (short _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (short _rv)")}, {"GetPortSpExtra", (PyCFunction)Qd_GetPortSpExtra, 1, - "(CGrafPtr port) -> (Fixed _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (Fixed _rv)")}, {"GetPortPenVisibility", (PyCFunction)Qd_GetPortPenVisibility, 1, - "(CGrafPtr port) -> (short _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (short _rv)")}, {"GetPortVisibleRegion", (PyCFunction)Qd_GetPortVisibleRegion, 1, - "(CGrafPtr port, RgnHandle visRgn) -> (RgnHandle _rv)"}, + PyDoc_STR("(CGrafPtr port, RgnHandle visRgn) -> (RgnHandle _rv)")}, {"GetPortClipRegion", (PyCFunction)Qd_GetPortClipRegion, 1, - "(CGrafPtr port, RgnHandle clipRgn) -> (RgnHandle _rv)"}, + PyDoc_STR("(CGrafPtr port, RgnHandle clipRgn) -> (RgnHandle _rv)")}, {"GetPortBackPixPat", (PyCFunction)Qd_GetPortBackPixPat, 1, - "(CGrafPtr port, PixPatHandle backPattern) -> (PixPatHandle _rv)"}, + PyDoc_STR("(CGrafPtr port, PixPatHandle backPattern) -> (PixPatHandle _rv)")}, {"GetPortPenPixPat", (PyCFunction)Qd_GetPortPenPixPat, 1, - "(CGrafPtr port, PixPatHandle penPattern) -> (PixPatHandle _rv)"}, + PyDoc_STR("(CGrafPtr port, PixPatHandle penPattern) -> (PixPatHandle _rv)")}, {"GetPortFillPixPat", (PyCFunction)Qd_GetPortFillPixPat, 1, - "(CGrafPtr port, PixPatHandle fillPattern) -> (PixPatHandle _rv)"}, + PyDoc_STR("(CGrafPtr port, PixPatHandle fillPattern) -> (PixPatHandle _rv)")}, {"GetPortPenSize", (PyCFunction)Qd_GetPortPenSize, 1, - "(CGrafPtr port, Point penSize) -> (Point penSize)"}, + PyDoc_STR("(CGrafPtr port, Point penSize) -> (Point penSize)")}, {"GetPortPenMode", (PyCFunction)Qd_GetPortPenMode, 1, - "(CGrafPtr port) -> (SInt32 _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (SInt32 _rv)")}, {"GetPortPenLocation", (PyCFunction)Qd_GetPortPenLocation, 1, - "(CGrafPtr port, Point penLocation) -> (Point penLocation)"}, + PyDoc_STR("(CGrafPtr port, Point penLocation) -> (Point penLocation)")}, {"IsPortRegionBeingDefined", (PyCFunction)Qd_IsPortRegionBeingDefined, 1, - "(CGrafPtr port) -> (Boolean _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")}, {"IsPortPictureBeingDefined", (PyCFunction)Qd_IsPortPictureBeingDefined, 1, - "(CGrafPtr port) -> (Boolean _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")}, #if TARGET_API_MAC_CARBON {"IsPortPolyBeingDefined", (PyCFunction)Qd_IsPortPolyBeingDefined, 1, - "(CGrafPtr port) -> (Boolean _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")}, #endif #if TARGET_API_MAC_CARBON {"IsPortOffscreen", (PyCFunction)Qd_IsPortOffscreen, 1, - "(CGrafPtr port) -> (Boolean _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")}, #endif #if TARGET_API_MAC_CARBON {"IsPortColor", (PyCFunction)Qd_IsPortColor, 1, - "(CGrafPtr port) -> (Boolean _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")}, #endif {"SetPortBounds", (PyCFunction)Qd_SetPortBounds, 1, - "(CGrafPtr port, Rect rect) -> None"}, + PyDoc_STR("(CGrafPtr port, Rect rect) -> None")}, {"SetPortOpColor", (PyCFunction)Qd_SetPortOpColor, 1, - "(CGrafPtr port, RGBColor opColor) -> None"}, + PyDoc_STR("(CGrafPtr port, RGBColor opColor) -> None")}, {"SetPortVisibleRegion", (PyCFunction)Qd_SetPortVisibleRegion, 1, - "(CGrafPtr port, RgnHandle visRgn) -> None"}, + PyDoc_STR("(CGrafPtr port, RgnHandle visRgn) -> None")}, {"SetPortClipRegion", (PyCFunction)Qd_SetPortClipRegion, 1, - "(CGrafPtr port, RgnHandle clipRgn) -> None"}, + PyDoc_STR("(CGrafPtr port, RgnHandle clipRgn) -> None")}, {"SetPortPenPixPat", (PyCFunction)Qd_SetPortPenPixPat, 1, - "(CGrafPtr port, PixPatHandle penPattern) -> None"}, + PyDoc_STR("(CGrafPtr port, PixPatHandle penPattern) -> None")}, {"SetPortFillPixPat", (PyCFunction)Qd_SetPortFillPixPat, 1, - "(CGrafPtr port, PixPatHandle penPattern) -> None"}, + PyDoc_STR("(CGrafPtr port, PixPatHandle penPattern) -> None")}, {"SetPortBackPixPat", (PyCFunction)Qd_SetPortBackPixPat, 1, - "(CGrafPtr port, PixPatHandle backPattern) -> None"}, + PyDoc_STR("(CGrafPtr port, PixPatHandle backPattern) -> None")}, {"SetPortPenSize", (PyCFunction)Qd_SetPortPenSize, 1, - "(CGrafPtr port, Point penSize) -> None"}, + PyDoc_STR("(CGrafPtr port, Point penSize) -> None")}, {"SetPortPenMode", (PyCFunction)Qd_SetPortPenMode, 1, - "(CGrafPtr port, SInt32 penMode) -> None"}, + PyDoc_STR("(CGrafPtr port, SInt32 penMode) -> None")}, {"SetPortFracHPenLocation", (PyCFunction)Qd_SetPortFracHPenLocation, 1, - "(CGrafPtr port, short pnLocHFrac) -> None"}, + PyDoc_STR("(CGrafPtr port, short pnLocHFrac) -> None")}, {"GetPixBounds", (PyCFunction)Qd_GetPixBounds, 1, - "(PixMapHandle pixMap) -> (Rect bounds)"}, + PyDoc_STR("(PixMapHandle pixMap) -> (Rect bounds)")}, {"GetPixDepth", (PyCFunction)Qd_GetPixDepth, 1, - "(PixMapHandle pixMap) -> (short _rv)"}, + PyDoc_STR("(PixMapHandle pixMap) -> (short _rv)")}, {"GetQDGlobalsRandomSeed", (PyCFunction)Qd_GetQDGlobalsRandomSeed, 1, - "() -> (long _rv)"}, + PyDoc_STR("() -> (long _rv)")}, {"GetQDGlobalsScreenBits", (PyCFunction)Qd_GetQDGlobalsScreenBits, 1, - "() -> (BitMap screenBits)"}, + PyDoc_STR("() -> (BitMap screenBits)")}, {"GetQDGlobalsArrow", (PyCFunction)Qd_GetQDGlobalsArrow, 1, - "() -> (Cursor arrow)"}, + PyDoc_STR("() -> (Cursor arrow)")}, {"GetQDGlobalsDarkGray", (PyCFunction)Qd_GetQDGlobalsDarkGray, 1, - "() -> (Pattern dkGray)"}, + PyDoc_STR("() -> (Pattern dkGray)")}, {"GetQDGlobalsLightGray", (PyCFunction)Qd_GetQDGlobalsLightGray, 1, - "() -> (Pattern ltGray)"}, + PyDoc_STR("() -> (Pattern ltGray)")}, {"GetQDGlobalsGray", (PyCFunction)Qd_GetQDGlobalsGray, 1, - "() -> (Pattern gray)"}, + PyDoc_STR("() -> (Pattern gray)")}, {"GetQDGlobalsBlack", (PyCFunction)Qd_GetQDGlobalsBlack, 1, - "() -> (Pattern black)"}, + PyDoc_STR("() -> (Pattern black)")}, {"GetQDGlobalsWhite", (PyCFunction)Qd_GetQDGlobalsWhite, 1, - "() -> (Pattern white)"}, + PyDoc_STR("() -> (Pattern white)")}, {"GetQDGlobalsThePort", (PyCFunction)Qd_GetQDGlobalsThePort, 1, - "() -> (CGrafPtr _rv)"}, + PyDoc_STR("() -> (CGrafPtr _rv)")}, {"SetQDGlobalsRandomSeed", (PyCFunction)Qd_SetQDGlobalsRandomSeed, 1, - "(long randomSeed) -> None"}, + PyDoc_STR("(long randomSeed) -> None")}, {"SetQDGlobalsArrow", (PyCFunction)Qd_SetQDGlobalsArrow, 1, - "(Cursor arrow) -> None"}, + PyDoc_STR("(Cursor arrow) -> None")}, {"GetRegionBounds", (PyCFunction)Qd_GetRegionBounds, 1, - "(RgnHandle region) -> (Rect bounds)"}, + PyDoc_STR("(RgnHandle region) -> (Rect bounds)")}, #if TARGET_API_MAC_CARBON {"IsRegionRectangular", (PyCFunction)Qd_IsRegionRectangular, 1, - "(RgnHandle region) -> (Boolean _rv)"}, + PyDoc_STR("(RgnHandle region) -> (Boolean _rv)")}, #endif #if TARGET_API_MAC_CARBON {"CreateNewPort", (PyCFunction)Qd_CreateNewPort, 1, - "() -> (CGrafPtr _rv)"}, + PyDoc_STR("() -> (CGrafPtr _rv)")}, #endif #if TARGET_API_MAC_CARBON {"DisposePort", (PyCFunction)Qd_DisposePort, 1, - "(CGrafPtr port) -> None"}, + PyDoc_STR("(CGrafPtr port) -> None")}, #endif #if TARGET_API_MAC_CARBON {"SetQDError", (PyCFunction)Qd_SetQDError, 1, - "(OSErr err) -> None"}, + PyDoc_STR("(OSErr err) -> None")}, #endif {"QDIsPortBuffered", (PyCFunction)Qd_QDIsPortBuffered, 1, - "(CGrafPtr port) -> (Boolean _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")}, {"QDIsPortBufferDirty", (PyCFunction)Qd_QDIsPortBufferDirty, 1, - "(CGrafPtr port) -> (Boolean _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")}, {"QDFlushPortBuffer", (PyCFunction)Qd_QDFlushPortBuffer, 1, - "(CGrafPtr port, RgnHandle region) -> None"}, + PyDoc_STR("(CGrafPtr port, RgnHandle region) -> None")}, #if TARGET_API_MAC_CARBON {"QDGetDirtyRegion", (PyCFunction)Qd_QDGetDirtyRegion, 1, - "(CGrafPtr port, RgnHandle rgn) -> None"}, + PyDoc_STR("(CGrafPtr port, RgnHandle rgn) -> None")}, #endif #if TARGET_API_MAC_CARBON {"QDSetDirtyRegion", (PyCFunction)Qd_QDSetDirtyRegion, 1, - "(CGrafPtr port, RgnHandle rgn) -> None"}, + PyDoc_STR("(CGrafPtr port, RgnHandle rgn) -> None")}, #endif {"LMGetScrVRes", (PyCFunction)Qd_LMGetScrVRes, 1, - "() -> (SInt16 _rv)"}, + PyDoc_STR("() -> (SInt16 _rv)")}, {"LMSetScrVRes", (PyCFunction)Qd_LMSetScrVRes, 1, - "(SInt16 value) -> None"}, + PyDoc_STR("(SInt16 value) -> None")}, {"LMGetScrHRes", (PyCFunction)Qd_LMGetScrHRes, 1, - "() -> (SInt16 _rv)"}, + PyDoc_STR("() -> (SInt16 _rv)")}, {"LMSetScrHRes", (PyCFunction)Qd_LMSetScrHRes, 1, - "(SInt16 value) -> None"}, + PyDoc_STR("(SInt16 value) -> None")}, {"LMGetMainDevice", (PyCFunction)Qd_LMGetMainDevice, 1, - "() -> (GDHandle _rv)"}, + PyDoc_STR("() -> (GDHandle _rv)")}, {"LMSetMainDevice", (PyCFunction)Qd_LMSetMainDevice, 1, - "(GDHandle value) -> None"}, + PyDoc_STR("(GDHandle value) -> None")}, {"LMGetDeviceList", (PyCFunction)Qd_LMGetDeviceList, 1, - "() -> (GDHandle _rv)"}, + PyDoc_STR("() -> (GDHandle _rv)")}, {"LMSetDeviceList", (PyCFunction)Qd_LMSetDeviceList, 1, - "(GDHandle value) -> None"}, + PyDoc_STR("(GDHandle value) -> None")}, {"LMGetQDColors", (PyCFunction)Qd_LMGetQDColors, 1, - "() -> (Handle _rv)"}, + PyDoc_STR("() -> (Handle _rv)")}, {"LMSetQDColors", (PyCFunction)Qd_LMSetQDColors, 1, - "(Handle value) -> None"}, + PyDoc_STR("(Handle value) -> None")}, {"LMGetWidthListHand", (PyCFunction)Qd_LMGetWidthListHand, 1, - "() -> (Handle _rv)"}, + PyDoc_STR("() -> (Handle _rv)")}, {"LMSetWidthListHand", (PyCFunction)Qd_LMSetWidthListHand, 1, - "(Handle value) -> None"}, + PyDoc_STR("(Handle value) -> None")}, {"LMGetHiliteMode", (PyCFunction)Qd_LMGetHiliteMode, 1, - "() -> (UInt8 _rv)"}, + PyDoc_STR("() -> (UInt8 _rv)")}, {"LMSetHiliteMode", (PyCFunction)Qd_LMSetHiliteMode, 1, - "(UInt8 value) -> None"}, + PyDoc_STR("(UInt8 value) -> None")}, {"LMGetWidthTabHandle", (PyCFunction)Qd_LMGetWidthTabHandle, 1, - "() -> (Handle _rv)"}, + PyDoc_STR("() -> (Handle _rv)")}, {"LMSetWidthTabHandle", (PyCFunction)Qd_LMSetWidthTabHandle, 1, - "(Handle value) -> None"}, + PyDoc_STR("(Handle value) -> None")}, {"LMGetLastSPExtra", (PyCFunction)Qd_LMGetLastSPExtra, 1, - "() -> (SInt32 _rv)"}, + PyDoc_STR("() -> (SInt32 _rv)")}, {"LMSetLastSPExtra", (PyCFunction)Qd_LMSetLastSPExtra, 1, - "(SInt32 value) -> None"}, + PyDoc_STR("(SInt32 value) -> None")}, {"LMGetLastFOND", (PyCFunction)Qd_LMGetLastFOND, 1, - "() -> (Handle _rv)"}, + PyDoc_STR("() -> (Handle _rv)")}, {"LMSetLastFOND", (PyCFunction)Qd_LMSetLastFOND, 1, - "(Handle value) -> None"}, + PyDoc_STR("(Handle value) -> None")}, {"LMGetFractEnable", (PyCFunction)Qd_LMGetFractEnable, 1, - "() -> (UInt8 _rv)"}, + PyDoc_STR("() -> (UInt8 _rv)")}, {"LMSetFractEnable", (PyCFunction)Qd_LMSetFractEnable, 1, - "(UInt8 value) -> None"}, + PyDoc_STR("(UInt8 value) -> None")}, {"LMGetTheGDevice", (PyCFunction)Qd_LMGetTheGDevice, 1, - "() -> (GDHandle _rv)"}, + PyDoc_STR("() -> (GDHandle _rv)")}, {"LMSetTheGDevice", (PyCFunction)Qd_LMSetTheGDevice, 1, - "(GDHandle value) -> None"}, + PyDoc_STR("(GDHandle value) -> None")}, {"LMGetHiliteRGB", (PyCFunction)Qd_LMGetHiliteRGB, 1, - "() -> (RGBColor hiliteRGBValue)"}, + PyDoc_STR("() -> (RGBColor hiliteRGBValue)")}, {"LMSetHiliteRGB", (PyCFunction)Qd_LMSetHiliteRGB, 1, - "(RGBColor hiliteRGBValue) -> None"}, + PyDoc_STR("(RGBColor hiliteRGBValue) -> None")}, {"LMGetCursorNew", (PyCFunction)Qd_LMGetCursorNew, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, {"LMSetCursorNew", (PyCFunction)Qd_LMSetCursorNew, 1, - "(Boolean value) -> None"}, + PyDoc_STR("(Boolean value) -> None")}, {"TextFont", (PyCFunction)Qd_TextFont, 1, - "(short font) -> None"}, + PyDoc_STR("(short font) -> None")}, {"TextFace", (PyCFunction)Qd_TextFace, 1, - "(StyleParameter face) -> None"}, + PyDoc_STR("(StyleParameter face) -> None")}, {"TextMode", (PyCFunction)Qd_TextMode, 1, - "(short mode) -> None"}, + PyDoc_STR("(short mode) -> None")}, {"TextSize", (PyCFunction)Qd_TextSize, 1, - "(short size) -> None"}, + PyDoc_STR("(short size) -> None")}, {"SpaceExtra", (PyCFunction)Qd_SpaceExtra, 1, - "(Fixed extra) -> None"}, + PyDoc_STR("(Fixed extra) -> None")}, {"DrawChar", (PyCFunction)Qd_DrawChar, 1, - "(CharParameter ch) -> None"}, + PyDoc_STR("(CharParameter ch) -> None")}, {"DrawString", (PyCFunction)Qd_DrawString, 1, - "(Str255 s) -> None"}, + PyDoc_STR("(Str255 s) -> None")}, {"MacDrawText", (PyCFunction)Qd_MacDrawText, 1, - "(Buffer textBuf, short firstByte, short byteCount) -> None"}, + PyDoc_STR("(Buffer textBuf, short firstByte, short byteCount) -> None")}, {"CharWidth", (PyCFunction)Qd_CharWidth, 1, - "(CharParameter ch) -> (short _rv)"}, + PyDoc_STR("(CharParameter ch) -> (short _rv)")}, {"StringWidth", (PyCFunction)Qd_StringWidth, 1, - "(Str255 s) -> (short _rv)"}, + PyDoc_STR("(Str255 s) -> (short _rv)")}, {"TextWidth", (PyCFunction)Qd_TextWidth, 1, - "(Buffer textBuf, short firstByte, short byteCount) -> (short _rv)"}, + PyDoc_STR("(Buffer textBuf, short firstByte, short byteCount) -> (short _rv)")}, {"GetFontInfo", (PyCFunction)Qd_GetFontInfo, 1, - "() -> (FontInfo info)"}, + PyDoc_STR("() -> (FontInfo info)")}, {"CharExtra", (PyCFunction)Qd_CharExtra, 1, - "(Fixed extra) -> None"}, + PyDoc_STR("(Fixed extra) -> None")}, {"TruncString", (PyCFunction)Qd_TruncString, 1, - "(short width, Str255 theString, TruncCode truncWhere) -> (short _rv)"}, + PyDoc_STR("(short width, Str255 theString, TruncCode truncWhere) -> (short _rv)")}, {"SetPort", (PyCFunction)Qd_SetPort, 1, - "(GrafPtr thePort) -> None"}, + PyDoc_STR("(GrafPtr thePort) -> None")}, {"GetCursor", (PyCFunction)Qd_GetCursor, 1, - "(short cursorID) -> (CursHandle _rv)"}, + PyDoc_STR("(short cursorID) -> (CursHandle _rv)")}, {"SetCursor", (PyCFunction)Qd_SetCursor, 1, - "(Cursor crsr) -> None"}, + PyDoc_STR("(Cursor crsr) -> None")}, {"ShowCursor", (PyCFunction)Qd_ShowCursor, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"LineTo", (PyCFunction)Qd_LineTo, 1, - "(short h, short v) -> None"}, + PyDoc_STR("(short h, short v) -> None")}, {"SetRect", (PyCFunction)Qd_SetRect, 1, - "(short left, short top, short right, short bottom) -> (Rect r)"}, + PyDoc_STR("(short left, short top, short right, short bottom) -> (Rect r)")}, {"OffsetRect", (PyCFunction)Qd_OffsetRect, 1, - "(Rect r, short dh, short dv) -> (Rect r)"}, + PyDoc_STR("(Rect r, short dh, short dv) -> (Rect r)")}, {"InsetRect", (PyCFunction)Qd_InsetRect, 1, - "(Rect r, short dh, short dv) -> (Rect r)"}, + PyDoc_STR("(Rect r, short dh, short dv) -> (Rect r)")}, {"UnionRect", (PyCFunction)Qd_UnionRect, 1, - "(Rect src1, Rect src2) -> (Rect dstRect)"}, + PyDoc_STR("(Rect src1, Rect src2) -> (Rect dstRect)")}, {"EqualRect", (PyCFunction)Qd_EqualRect, 1, - "(Rect rect1, Rect rect2) -> (Boolean _rv)"}, + PyDoc_STR("(Rect rect1, Rect rect2) -> (Boolean _rv)")}, {"FrameRect", (PyCFunction)Qd_FrameRect, 1, - "(Rect r) -> None"}, + PyDoc_STR("(Rect r) -> None")}, {"InvertRect", (PyCFunction)Qd_InvertRect, 1, - "(Rect r) -> None"}, + PyDoc_STR("(Rect r) -> None")}, {"FillRect", (PyCFunction)Qd_FillRect, 1, - "(Rect r, Pattern pat) -> None"}, + PyDoc_STR("(Rect r, Pattern pat) -> None")}, {"CopyRgn", (PyCFunction)Qd_CopyRgn, 1, - "(RgnHandle srcRgn, RgnHandle dstRgn) -> None"}, + PyDoc_STR("(RgnHandle srcRgn, RgnHandle dstRgn) -> None")}, {"SetRectRgn", (PyCFunction)Qd_SetRectRgn, 1, - "(RgnHandle rgn, short left, short top, short right, short bottom) -> None"}, + PyDoc_STR("(RgnHandle rgn, short left, short top, short right, short bottom) -> None")}, {"OffsetRgn", (PyCFunction)Qd_OffsetRgn, 1, - "(RgnHandle rgn, short dh, short dv) -> None"}, + PyDoc_STR("(RgnHandle rgn, short dh, short dv) -> None")}, {"UnionRgn", (PyCFunction)Qd_UnionRgn, 1, - "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"}, + PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")}, {"XorRgn", (PyCFunction)Qd_XorRgn, 1, - "(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"}, + PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")}, {"EqualRgn", (PyCFunction)Qd_EqualRgn, 1, - "(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)"}, + PyDoc_STR("(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)")}, {"FrameRgn", (PyCFunction)Qd_FrameRgn, 1, - "(RgnHandle rgn) -> None"}, + PyDoc_STR("(RgnHandle rgn) -> None")}, {"PaintRgn", (PyCFunction)Qd_PaintRgn, 1, - "(RgnHandle rgn) -> None"}, + PyDoc_STR("(RgnHandle rgn) -> None")}, {"InvertRgn", (PyCFunction)Qd_InvertRgn, 1, - "(RgnHandle rgn) -> None"}, + PyDoc_STR("(RgnHandle rgn) -> None")}, {"FillRgn", (PyCFunction)Qd_FillRgn, 1, - "(RgnHandle rgn, Pattern pat) -> None"}, + PyDoc_STR("(RgnHandle rgn, Pattern pat) -> None")}, {"GetPixel", (PyCFunction)Qd_GetPixel, 1, - "(short h, short v) -> (Boolean _rv)"}, + PyDoc_STR("(short h, short v) -> (Boolean _rv)")}, {"PtInRect", (PyCFunction)Qd_PtInRect, 1, - "(Point pt, Rect r) -> (Boolean _rv)"}, + PyDoc_STR("(Point pt, Rect r) -> (Boolean _rv)")}, {"DrawText", (PyCFunction)Qd_DrawText, 1, - "(Buffer textBuf, short firstByte, short byteCount) -> None"}, + PyDoc_STR("(Buffer textBuf, short firstByte, short byteCount) -> None")}, {"BitMap", (PyCFunction)Qd_BitMap, 1, - "Take (string, int, Rect) argument and create BitMap"}, + PyDoc_STR("Take (string, int, Rect) argument and create BitMap")}, {"RawBitMap", (PyCFunction)Qd_RawBitMap, 1, - "Take string BitMap and turn into BitMap object"}, + PyDoc_STR("Take string BitMap and turn into BitMap object")}, {NULL, NULL, 0} }; diff --git a/Mac/Modules/qdoffs/_Qdoffsmodule.c b/Mac/Modules/qdoffs/_Qdoffsmodule.c index 2f951d1..c75daac 100644 --- a/Mac/Modules/qdoffs/_Qdoffsmodule.c +++ b/Mac/Modules/qdoffs/_Qdoffsmodule.c @@ -123,11 +123,11 @@ static PyObject *GWorldObj_as_GrafPtr(GWorldObject *_self, PyObject *_args) static PyMethodDef GWorldObj_methods[] = { {"GetGWorldDevice", (PyCFunction)GWorldObj_GetGWorldDevice, 1, - "() -> (GDHandle _rv)"}, + PyDoc_STR("() -> (GDHandle _rv)")}, {"GetGWorldPixMap", (PyCFunction)GWorldObj_GetGWorldPixMap, 1, - "() -> (PixMapHandle _rv)"}, + PyDoc_STR("() -> (PixMapHandle _rv)")}, {"as_GrafPtr", (PyCFunction)GWorldObj_as_GrafPtr, 1, - "() -> (GrafPtr _rv)"}, + PyDoc_STR("() -> (GrafPtr _rv)")}, {NULL, NULL, 0} }; @@ -604,51 +604,51 @@ static PyObject *Qdoffs_PutPixMapBytes(PyObject *_self, PyObject *_args) static PyMethodDef Qdoffs_methods[] = { {"NewGWorld", (PyCFunction)Qdoffs_NewGWorld, 1, - "(short PixelDepth, Rect boundsRect, CTabHandle cTable, GDHandle aGDevice, GWorldFlags flags) -> (GWorldPtr offscreenGWorld)"}, + PyDoc_STR("(short PixelDepth, Rect boundsRect, CTabHandle cTable, GDHandle aGDevice, GWorldFlags flags) -> (GWorldPtr offscreenGWorld)")}, {"LockPixels", (PyCFunction)Qdoffs_LockPixels, 1, - "(PixMapHandle pm) -> (Boolean _rv)"}, + PyDoc_STR("(PixMapHandle pm) -> (Boolean _rv)")}, {"UnlockPixels", (PyCFunction)Qdoffs_UnlockPixels, 1, - "(PixMapHandle pm) -> None"}, + PyDoc_STR("(PixMapHandle pm) -> None")}, {"UpdateGWorld", (PyCFunction)Qdoffs_UpdateGWorld, 1, - "(short pixelDepth, Rect boundsRect, CTabHandle cTable, GDHandle aGDevice, GWorldFlags flags) -> (GWorldFlags _rv, GWorldPtr offscreenGWorld)"}, + PyDoc_STR("(short pixelDepth, Rect boundsRect, CTabHandle cTable, GDHandle aGDevice, GWorldFlags flags) -> (GWorldFlags _rv, GWorldPtr offscreenGWorld)")}, {"GetGWorld", (PyCFunction)Qdoffs_GetGWorld, 1, - "() -> (CGrafPtr port, GDHandle gdh)"}, + PyDoc_STR("() -> (CGrafPtr port, GDHandle gdh)")}, {"SetGWorld", (PyCFunction)Qdoffs_SetGWorld, 1, - "(CGrafPtr port, GDHandle gdh) -> None"}, + PyDoc_STR("(CGrafPtr port, GDHandle gdh) -> None")}, {"CTabChanged", (PyCFunction)Qdoffs_CTabChanged, 1, - "(CTabHandle ctab) -> None"}, + PyDoc_STR("(CTabHandle ctab) -> None")}, {"PixPatChanged", (PyCFunction)Qdoffs_PixPatChanged, 1, - "(PixPatHandle ppat) -> None"}, + PyDoc_STR("(PixPatHandle ppat) -> None")}, {"PortChanged", (PyCFunction)Qdoffs_PortChanged, 1, - "(GrafPtr port) -> None"}, + PyDoc_STR("(GrafPtr port) -> None")}, {"GDeviceChanged", (PyCFunction)Qdoffs_GDeviceChanged, 1, - "(GDHandle gdh) -> None"}, + PyDoc_STR("(GDHandle gdh) -> None")}, {"AllowPurgePixels", (PyCFunction)Qdoffs_AllowPurgePixels, 1, - "(PixMapHandle pm) -> None"}, + PyDoc_STR("(PixMapHandle pm) -> None")}, {"NoPurgePixels", (PyCFunction)Qdoffs_NoPurgePixels, 1, - "(PixMapHandle pm) -> None"}, + PyDoc_STR("(PixMapHandle pm) -> None")}, {"GetPixelsState", (PyCFunction)Qdoffs_GetPixelsState, 1, - "(PixMapHandle pm) -> (GWorldFlags _rv)"}, + PyDoc_STR("(PixMapHandle pm) -> (GWorldFlags _rv)")}, {"SetPixelsState", (PyCFunction)Qdoffs_SetPixelsState, 1, - "(PixMapHandle pm, GWorldFlags state) -> None"}, + PyDoc_STR("(PixMapHandle pm, GWorldFlags state) -> None")}, {"GetPixRowBytes", (PyCFunction)Qdoffs_GetPixRowBytes, 1, - "(PixMapHandle pm) -> (long _rv)"}, + PyDoc_STR("(PixMapHandle pm) -> (long _rv)")}, {"NewScreenBuffer", (PyCFunction)Qdoffs_NewScreenBuffer, 1, - "(Rect globalRect, Boolean purgeable) -> (GDHandle gdh, PixMapHandle offscreenPixMap)"}, + PyDoc_STR("(Rect globalRect, Boolean purgeable) -> (GDHandle gdh, PixMapHandle offscreenPixMap)")}, {"DisposeScreenBuffer", (PyCFunction)Qdoffs_DisposeScreenBuffer, 1, - "(PixMapHandle offscreenPixMap) -> None"}, + PyDoc_STR("(PixMapHandle offscreenPixMap) -> None")}, {"QDDone", (PyCFunction)Qdoffs_QDDone, 1, - "(GrafPtr port) -> (Boolean _rv)"}, + PyDoc_STR("(GrafPtr port) -> (Boolean _rv)")}, {"OffscreenVersion", (PyCFunction)Qdoffs_OffscreenVersion, 1, - "() -> (long _rv)"}, + PyDoc_STR("() -> (long _rv)")}, {"NewTempScreenBuffer", (PyCFunction)Qdoffs_NewTempScreenBuffer, 1, - "(Rect globalRect, Boolean purgeable) -> (GDHandle gdh, PixMapHandle offscreenPixMap)"}, + PyDoc_STR("(Rect globalRect, Boolean purgeable) -> (GDHandle gdh, PixMapHandle offscreenPixMap)")}, {"PixMap32Bit", (PyCFunction)Qdoffs_PixMap32Bit, 1, - "(PixMapHandle pmHandle) -> (Boolean _rv)"}, + PyDoc_STR("(PixMapHandle pmHandle) -> (Boolean _rv)")}, {"GetPixMapBytes", (PyCFunction)Qdoffs_GetPixMapBytes, 1, - "(pixmap, int start, int size) -> string. Return bytes from the pixmap"}, + PyDoc_STR("(pixmap, int start, int size) -> string. Return bytes from the pixmap")}, {"PutPixMapBytes", (PyCFunction)Qdoffs_PutPixMapBytes, 1, - "(pixmap, int start, string data). Store bytes into the pixmap"}, + PyDoc_STR("(pixmap, int start, string data). Store bytes into the pixmap")}, {NULL, NULL, 0} }; 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} }; diff --git a/Mac/Modules/res/_Resmodule.c b/Mac/Modules/res/_Resmodule.c index 2dbea6d..5665c47 100644 --- a/Mac/Modules/res/_Resmodule.c +++ b/Mac/Modules/res/_Resmodule.c @@ -501,50 +501,50 @@ static PyObject *ResObj_AutoDispose(ResourceObject *_self, PyObject *_args) static PyMethodDef ResObj_methods[] = { {"HomeResFile", (PyCFunction)ResObj_HomeResFile, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, {"MacLoadResource", (PyCFunction)ResObj_MacLoadResource, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"ReleaseResource", (PyCFunction)ResObj_ReleaseResource, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"DetachResource", (PyCFunction)ResObj_DetachResource, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"GetResAttrs", (PyCFunction)ResObj_GetResAttrs, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, {"GetResInfo", (PyCFunction)ResObj_GetResInfo, 1, - "() -> (short theID, ResType theType, Str255 name)"}, + PyDoc_STR("() -> (short theID, ResType theType, Str255 name)")}, {"SetResInfo", (PyCFunction)ResObj_SetResInfo, 1, - "(short theID, Str255 name) -> None"}, + PyDoc_STR("(short theID, Str255 name) -> None")}, {"AddResource", (PyCFunction)ResObj_AddResource, 1, - "(ResType theType, short theID, Str255 name) -> None"}, + PyDoc_STR("(ResType theType, short theID, Str255 name) -> None")}, {"GetResourceSizeOnDisk", (PyCFunction)ResObj_GetResourceSizeOnDisk, 1, - "() -> (long _rv)"}, + PyDoc_STR("() -> (long _rv)")}, {"GetMaxResourceSize", (PyCFunction)ResObj_GetMaxResourceSize, 1, - "() -> (long _rv)"}, + PyDoc_STR("() -> (long _rv)")}, #if TARGET_API_MAC_OS8 {"RsrcMapEntry", (PyCFunction)ResObj_RsrcMapEntry, 1, - "() -> (long _rv)"}, + PyDoc_STR("() -> (long _rv)")}, #endif {"SetResAttrs", (PyCFunction)ResObj_SetResAttrs, 1, - "(short attrs) -> None"}, + PyDoc_STR("(short attrs) -> None")}, {"ChangedResource", (PyCFunction)ResObj_ChangedResource, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"RemoveResource", (PyCFunction)ResObj_RemoveResource, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"WriteResource", (PyCFunction)ResObj_WriteResource, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"SetResourceSize", (PyCFunction)ResObj_SetResourceSize, 1, - "(long newSize) -> None"}, + PyDoc_STR("(long newSize) -> None")}, {"GetNextFOND", (PyCFunction)ResObj_GetNextFOND, 1, - "() -> (Handle _rv)"}, + PyDoc_STR("() -> (Handle _rv)")}, {"as_Control", (PyCFunction)ResObj_as_Control, 1, - "Return this resource/handle as a Control"}, + PyDoc_STR("Return this resource/handle as a Control")}, {"as_Menu", (PyCFunction)ResObj_as_Menu, 1, - "Return this resource/handle as a Menu"}, + PyDoc_STR("Return this resource/handle as a Menu")}, {"LoadResource", (PyCFunction)ResObj_LoadResource, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"AutoDispose", (PyCFunction)ResObj_AutoDispose, 1, - "(int)->int. Automatically DisposeHandle the object on Python object cleanup"}, + PyDoc_STR("(int)->int. Automatically DisposeHandle the object on Python object cleanup")}, {NULL, NULL, 0} }; @@ -1720,134 +1720,134 @@ static PyMethodDef Res_methods[] = { #if TARGET_API_MAC_OS8 {"InitResources", (PyCFunction)Res_InitResources, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, #endif #if TARGET_API_MAC_OS8 {"RsrcZoneInit", (PyCFunction)Res_RsrcZoneInit, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif {"CloseResFile", (PyCFunction)Res_CloseResFile, 1, - "(short refNum) -> None"}, + PyDoc_STR("(short refNum) -> None")}, {"ResError", (PyCFunction)Res_ResError, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CurResFile", (PyCFunction)Res_CurResFile, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, #if TARGET_API_MAC_OS8 {"CreateResFile", (PyCFunction)Res_CreateResFile, 1, - "(Str255 fileName) -> None"}, + PyDoc_STR("(Str255 fileName) -> None")}, #endif #if TARGET_API_MAC_OS8 {"OpenResFile", (PyCFunction)Res_OpenResFile, 1, - "(Str255 fileName) -> (short _rv)"}, + PyDoc_STR("(Str255 fileName) -> (short _rv)")}, #endif {"UseResFile", (PyCFunction)Res_UseResFile, 1, - "(short refNum) -> None"}, + PyDoc_STR("(short refNum) -> None")}, {"CountTypes", (PyCFunction)Res_CountTypes, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, {"Count1Types", (PyCFunction)Res_Count1Types, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, {"GetIndType", (PyCFunction)Res_GetIndType, 1, - "(short index) -> (ResType theType)"}, + PyDoc_STR("(short index) -> (ResType theType)")}, {"Get1IndType", (PyCFunction)Res_Get1IndType, 1, - "(short index) -> (ResType theType)"}, + PyDoc_STR("(short index) -> (ResType theType)")}, {"SetResLoad", (PyCFunction)Res_SetResLoad, 1, - "(Boolean load) -> None"}, + PyDoc_STR("(Boolean load) -> None")}, {"CountResources", (PyCFunction)Res_CountResources, 1, - "(ResType theType) -> (short _rv)"}, + PyDoc_STR("(ResType theType) -> (short _rv)")}, {"Count1Resources", (PyCFunction)Res_Count1Resources, 1, - "(ResType theType) -> (short _rv)"}, + PyDoc_STR("(ResType theType) -> (short _rv)")}, {"GetIndResource", (PyCFunction)Res_GetIndResource, 1, - "(ResType theType, short index) -> (Handle _rv)"}, + PyDoc_STR("(ResType theType, short index) -> (Handle _rv)")}, {"Get1IndResource", (PyCFunction)Res_Get1IndResource, 1, - "(ResType theType, short index) -> (Handle _rv)"}, + PyDoc_STR("(ResType theType, short index) -> (Handle _rv)")}, {"GetResource", (PyCFunction)Res_GetResource, 1, - "(ResType theType, short theID) -> (Handle _rv)"}, + PyDoc_STR("(ResType theType, short theID) -> (Handle _rv)")}, {"Get1Resource", (PyCFunction)Res_Get1Resource, 1, - "(ResType theType, short theID) -> (Handle _rv)"}, + PyDoc_STR("(ResType theType, short theID) -> (Handle _rv)")}, {"GetNamedResource", (PyCFunction)Res_GetNamedResource, 1, - "(ResType theType, Str255 name) -> (Handle _rv)"}, + PyDoc_STR("(ResType theType, Str255 name) -> (Handle _rv)")}, {"Get1NamedResource", (PyCFunction)Res_Get1NamedResource, 1, - "(ResType theType, Str255 name) -> (Handle _rv)"}, + PyDoc_STR("(ResType theType, Str255 name) -> (Handle _rv)")}, {"UniqueID", (PyCFunction)Res_UniqueID, 1, - "(ResType theType) -> (short _rv)"}, + PyDoc_STR("(ResType theType) -> (short _rv)")}, {"Unique1ID", (PyCFunction)Res_Unique1ID, 1, - "(ResType theType) -> (short _rv)"}, + PyDoc_STR("(ResType theType) -> (short _rv)")}, {"UpdateResFile", (PyCFunction)Res_UpdateResFile, 1, - "(short refNum) -> None"}, + PyDoc_STR("(short refNum) -> None")}, {"SetResPurge", (PyCFunction)Res_SetResPurge, 1, - "(Boolean install) -> None"}, + PyDoc_STR("(Boolean install) -> None")}, {"GetResFileAttrs", (PyCFunction)Res_GetResFileAttrs, 1, - "(short refNum) -> (short _rv)"}, + PyDoc_STR("(short refNum) -> (short _rv)")}, {"SetResFileAttrs", (PyCFunction)Res_SetResFileAttrs, 1, - "(short refNum, short attrs) -> None"}, + PyDoc_STR("(short refNum, short attrs) -> None")}, {"OpenRFPerm", (PyCFunction)Res_OpenRFPerm, 1, - "(Str255 fileName, short vRefNum, SignedByte permission) -> (short _rv)"}, + PyDoc_STR("(Str255 fileName, short vRefNum, SignedByte permission) -> (short _rv)")}, #if TARGET_API_MAC_OS8 {"RGetResource", (PyCFunction)Res_RGetResource, 1, - "(ResType theType, short theID) -> (Handle _rv)"}, + PyDoc_STR("(ResType theType, short theID) -> (Handle _rv)")}, #endif {"HOpenResFile", (PyCFunction)Res_HOpenResFile, 1, - "(short vRefNum, long dirID, Str255 fileName, SignedByte permission) -> (short _rv)"}, + PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SignedByte permission) -> (short _rv)")}, {"HCreateResFile", (PyCFunction)Res_HCreateResFile, 1, - "(short vRefNum, long dirID, Str255 fileName) -> None"}, + PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")}, {"FSpOpenResFile", (PyCFunction)Res_FSpOpenResFile, 1, - "(FSSpec spec, SignedByte permission) -> (short _rv)"}, + PyDoc_STR("(FSSpec spec, SignedByte permission) -> (short _rv)")}, {"FSpCreateResFile", (PyCFunction)Res_FSpCreateResFile, 1, - "(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None"}, + PyDoc_STR("(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None")}, #if TARGET_API_MAC_CARBON {"InsertResourceFile", (PyCFunction)Res_InsertResourceFile, 1, - "(SInt16 refNum, RsrcChainLocation where) -> None"}, + PyDoc_STR("(SInt16 refNum, RsrcChainLocation where) -> None")}, #endif #if TARGET_API_MAC_CARBON {"DetachResourceFile", (PyCFunction)Res_DetachResourceFile, 1, - "(SInt16 refNum) -> None"}, + PyDoc_STR("(SInt16 refNum) -> None")}, #endif #if TARGET_API_MAC_CARBON {"FSpResourceFileAlreadyOpen", (PyCFunction)Res_FSpResourceFileAlreadyOpen, 1, - "(FSSpec resourceFile) -> (Boolean _rv, Boolean inChain, SInt16 refNum)"}, + PyDoc_STR("(FSSpec resourceFile) -> (Boolean _rv, Boolean inChain, SInt16 refNum)")}, #endif #if TARGET_API_MAC_CARBON {"FSpOpenOrphanResFile", (PyCFunction)Res_FSpOpenOrphanResFile, 1, - "(FSSpec spec, SignedByte permission) -> (SInt16 refNum)"}, + PyDoc_STR("(FSSpec spec, SignedByte permission) -> (SInt16 refNum)")}, #endif #if TARGET_API_MAC_CARBON {"GetTopResourceFile", (PyCFunction)Res_GetTopResourceFile, 1, - "() -> (SInt16 refNum)"}, + PyDoc_STR("() -> (SInt16 refNum)")}, #endif #if TARGET_API_MAC_CARBON {"GetNextResourceFile", (PyCFunction)Res_GetNextResourceFile, 1, - "(SInt16 curRefNum) -> (SInt16 nextRefNum)"}, + PyDoc_STR("(SInt16 curRefNum) -> (SInt16 nextRefNum)")}, #endif {"FSOpenResFile", (PyCFunction)Res_FSOpenResFile, 1, - "(FSRef ref, SignedByte permission) -> (short _rv)"}, + PyDoc_STR("(FSRef ref, SignedByte permission) -> (short _rv)")}, {"FSCreateResFile", (PyCFunction)Res_FSCreateResFile, 1, - "(FSRef parentRef, Buffer nameLength) -> (FSRef newRef, FSSpec newSpec)"}, + PyDoc_STR("(FSRef parentRef, Buffer nameLength) -> (FSRef newRef, FSSpec newSpec)")}, {"FSResourceFileAlreadyOpen", (PyCFunction)Res_FSResourceFileAlreadyOpen, 1, - "(FSRef resourceFileRef) -> (Boolean _rv, Boolean inChain, SInt16 refNum)"}, + PyDoc_STR("(FSRef resourceFileRef) -> (Boolean _rv, Boolean inChain, SInt16 refNum)")}, #if TARGET_API_MAC_CARBON {"FSCreateResourceFile", (PyCFunction)Res_FSCreateResourceFile, 1, - "(FSRef parentRef, Buffer nameLength, Buffer forkNameLength) -> (FSRef newRef, FSSpec newSpec)"}, + PyDoc_STR("(FSRef parentRef, Buffer nameLength, Buffer forkNameLength) -> (FSRef newRef, FSSpec newSpec)")}, #endif #if TARGET_API_MAC_CARBON {"FSOpenResourceFile", (PyCFunction)Res_FSOpenResourceFile, 1, - "(FSRef ref, Buffer forkNameLength, SignedByte permissions) -> (SInt16 refNum)"}, + PyDoc_STR("(FSRef ref, Buffer forkNameLength, SignedByte permissions) -> (SInt16 refNum)")}, #endif {"Resource", (PyCFunction)Res_Resource, 1, - "Convert a string to a resource object.\n\nThe created resource object is actually just a handle,\napply AddResource() to write it to a resource file.\nSee also the Handle() docstring.\n"}, + PyDoc_STR("Convert a string to a resource object.\n\nThe created resource object is actually just a handle,\napply AddResource() to write it to a resource file.\nSee also the Handle() docstring.\n")}, {"Handle", (PyCFunction)Res_Handle, 1, - "Convert a string to a Handle object.\n\nResource() and Handle() are very similar, but objects created with Handle() are\nby default automatically DisposeHandle()d upon object cleanup. Use AutoDispose()\nto change this.\n"}, + PyDoc_STR("Convert a string to a Handle object.\n\nResource() and Handle() are very similar, but objects created with Handle() are\nby default automatically DisposeHandle()d upon object cleanup. Use AutoDispose()\nto change this.\n")}, {NULL, NULL, 0} }; diff --git a/Mac/Modules/snd/_Sndmodule.c b/Mac/Modules/snd/_Sndmodule.c index 7a8f9fd..7ce4799 100644 --- a/Mac/Modules/snd/_Sndmodule.c +++ b/Mac/Modules/snd/_Sndmodule.c @@ -271,32 +271,32 @@ static PyObject *SndCh_SndSetInfo(SndChannelObject *_self, PyObject *_args) static PyMethodDef SndCh_methods[] = { {"SndDoCommand", (PyCFunction)SndCh_SndDoCommand, 1, - "(SndCommand cmd, Boolean noWait) -> None"}, + PyDoc_STR("(SndCommand cmd, Boolean noWait) -> None")}, {"SndDoImmediate", (PyCFunction)SndCh_SndDoImmediate, 1, - "(SndCommand cmd) -> None"}, + PyDoc_STR("(SndCommand cmd) -> None")}, {"SndPlay", (PyCFunction)SndCh_SndPlay, 1, - "(SndListHandle sndHandle, Boolean async) -> None"}, + PyDoc_STR("(SndListHandle sndHandle, Boolean async) -> None")}, #if !TARGET_API_MAC_CARBON {"SndStartFilePlay", (PyCFunction)SndCh_SndStartFilePlay, 1, - "(short fRefNum, short resNum, long bufferSize, Boolean async) -> None"}, + PyDoc_STR("(short fRefNum, short resNum, long bufferSize, Boolean async) -> None")}, #endif #if !TARGET_API_MAC_CARBON {"SndPauseFilePlay", (PyCFunction)SndCh_SndPauseFilePlay, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if !TARGET_API_MAC_CARBON {"SndStopFilePlay", (PyCFunction)SndCh_SndStopFilePlay, 1, - "(Boolean quietNow) -> None"}, + PyDoc_STR("(Boolean quietNow) -> None")}, #endif {"SndChannelStatus", (PyCFunction)SndCh_SndChannelStatus, 1, - "(short theLength) -> (SCStatus theStatus)"}, + PyDoc_STR("(short theLength) -> (SCStatus theStatus)")}, {"SndGetInfo", (PyCFunction)SndCh_SndGetInfo, 1, - "(OSType selector, void * infoPtr) -> None"}, + PyDoc_STR("(OSType selector, void * infoPtr) -> None")}, {"SndSetInfo", (PyCFunction)SndCh_SndSetInfo, 1, - "(OSType selector, void * infoPtr) -> None"}, + PyDoc_STR("(OSType selector, void * infoPtr) -> None")}, {NULL, NULL, 0} }; @@ -1292,109 +1292,109 @@ static PyObject *Snd_SPBBytesToMilliseconds(PyObject *_self, PyObject *_args) static PyMethodDef Snd_methods[] = { {"SPB", (PyCFunction)Snd_SPB, 1, - NULL}, + PyDoc_STR(NULL)}, {"SysBeep", (PyCFunction)Snd_SysBeep, 1, - "(short duration) -> None"}, + PyDoc_STR("(short duration) -> None")}, {"SndNewChannel", (PyCFunction)Snd_SndNewChannel, 1, - "(short synth, long init, PyObject* userRoutine) -> (SndChannelPtr chan)"}, + PyDoc_STR("(short synth, long init, PyObject* userRoutine) -> (SndChannelPtr chan)")}, #if !TARGET_API_MAC_CARBON {"SndControl", (PyCFunction)Snd_SndControl, 1, - "(short id) -> (SndCommand cmd)"}, + PyDoc_STR("(short id) -> (SndCommand cmd)")}, #endif {"SndSoundManagerVersion", (PyCFunction)Snd_SndSoundManagerVersion, 1, - "() -> (NumVersion _rv)"}, + PyDoc_STR("() -> (NumVersion _rv)")}, {"SndManagerStatus", (PyCFunction)Snd_SndManagerStatus, 1, - "(short theLength) -> (SMStatus theStatus)"}, + PyDoc_STR("(short theLength) -> (SMStatus theStatus)")}, {"SndGetSysBeepState", (PyCFunction)Snd_SndGetSysBeepState, 1, - "() -> (short sysBeepState)"}, + PyDoc_STR("() -> (short sysBeepState)")}, {"SndSetSysBeepState", (PyCFunction)Snd_SndSetSysBeepState, 1, - "(short sysBeepState) -> None"}, + PyDoc_STR("(short sysBeepState) -> None")}, #if !TARGET_API_MAC_CARBON {"MACEVersion", (PyCFunction)Snd_MACEVersion, 1, - "() -> (NumVersion _rv)"}, + PyDoc_STR("() -> (NumVersion _rv)")}, #endif #if !TARGET_API_MAC_CARBON {"Comp3to1", (PyCFunction)Snd_Comp3to1, 1, - "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"}, + PyDoc_STR("(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)")}, #endif #if !TARGET_API_MAC_CARBON {"Exp1to3", (PyCFunction)Snd_Exp1to3, 1, - "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"}, + PyDoc_STR("(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)")}, #endif #if !TARGET_API_MAC_CARBON {"Comp6to1", (PyCFunction)Snd_Comp6to1, 1, - "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"}, + PyDoc_STR("(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)")}, #endif #if !TARGET_API_MAC_CARBON {"Exp1to6", (PyCFunction)Snd_Exp1to6, 1, - "(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"}, + PyDoc_STR("(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)")}, #endif {"GetSysBeepVolume", (PyCFunction)Snd_GetSysBeepVolume, 1, - "() -> (long level)"}, + PyDoc_STR("() -> (long level)")}, {"SetSysBeepVolume", (PyCFunction)Snd_SetSysBeepVolume, 1, - "(long level) -> None"}, + PyDoc_STR("(long level) -> None")}, {"GetDefaultOutputVolume", (PyCFunction)Snd_GetDefaultOutputVolume, 1, - "() -> (long level)"}, + PyDoc_STR("() -> (long level)")}, {"SetDefaultOutputVolume", (PyCFunction)Snd_SetDefaultOutputVolume, 1, - "(long level) -> None"}, + PyDoc_STR("(long level) -> None")}, {"GetSoundHeaderOffset", (PyCFunction)Snd_GetSoundHeaderOffset, 1, - "(SndListHandle sndHandle) -> (long offset)"}, + PyDoc_STR("(SndListHandle sndHandle) -> (long offset)")}, {"GetCompressionInfo", (PyCFunction)Snd_GetCompressionInfo, 1, - "(short compressionID, OSType format, short numChannels, short sampleSize) -> (CompressionInfo cp)"}, + PyDoc_STR("(short compressionID, OSType format, short numChannels, short sampleSize) -> (CompressionInfo cp)")}, {"SetSoundPreference", (PyCFunction)Snd_SetSoundPreference, 1, - "(OSType theType, Handle settings) -> (Str255 name)"}, + PyDoc_STR("(OSType theType, Handle settings) -> (Str255 name)")}, {"GetSoundPreference", (PyCFunction)Snd_GetSoundPreference, 1, - "(OSType theType, Handle settings) -> (Str255 name)"}, + PyDoc_STR("(OSType theType, Handle settings) -> (Str255 name)")}, {"GetCompressionName", (PyCFunction)Snd_GetCompressionName, 1, - "(OSType compressionType) -> (Str255 compressionName)"}, + PyDoc_STR("(OSType compressionType) -> (Str255 compressionName)")}, {"SPBVersion", (PyCFunction)Snd_SPBVersion, 1, - "() -> (NumVersion _rv)"}, + PyDoc_STR("() -> (NumVersion _rv)")}, {"SndRecord", (PyCFunction)Snd_SndRecord, 1, - "(Point corner, OSType quality) -> (SndListHandle sndHandle)"}, + PyDoc_STR("(Point corner, OSType quality) -> (SndListHandle sndHandle)")}, #if !TARGET_API_MAC_CARBON {"SndRecordToFile", (PyCFunction)Snd_SndRecordToFile, 1, - "(Point corner, OSType quality, short fRefNum) -> None"}, + PyDoc_STR("(Point corner, OSType quality, short fRefNum) -> None")}, #endif {"SPBSignInDevice", (PyCFunction)Snd_SPBSignInDevice, 1, - "(short deviceRefNum, Str255 deviceName) -> None"}, + PyDoc_STR("(short deviceRefNum, Str255 deviceName) -> None")}, {"SPBSignOutDevice", (PyCFunction)Snd_SPBSignOutDevice, 1, - "(short deviceRefNum) -> None"}, + PyDoc_STR("(short deviceRefNum) -> None")}, {"SPBGetIndexedDevice", (PyCFunction)Snd_SPBGetIndexedDevice, 1, - "(short count) -> (Str255 deviceName, Handle deviceIconHandle)"}, + PyDoc_STR("(short count) -> (Str255 deviceName, Handle deviceIconHandle)")}, {"SPBOpenDevice", (PyCFunction)Snd_SPBOpenDevice, 1, - "(Str255 deviceName, short permission) -> (long inRefNum)"}, + PyDoc_STR("(Str255 deviceName, short permission) -> (long inRefNum)")}, {"SPBCloseDevice", (PyCFunction)Snd_SPBCloseDevice, 1, - "(long inRefNum) -> None"}, + PyDoc_STR("(long inRefNum) -> None")}, {"SPBRecord", (PyCFunction)Snd_SPBRecord, 1, - "(SPBPtr inParamPtr, Boolean asynchFlag) -> None"}, + PyDoc_STR("(SPBPtr inParamPtr, Boolean asynchFlag) -> None")}, #if !TARGET_API_MAC_CARBON {"SPBRecordToFile", (PyCFunction)Snd_SPBRecordToFile, 1, - "(short fRefNum, SPBPtr inParamPtr, Boolean asynchFlag) -> None"}, + PyDoc_STR("(short fRefNum, SPBPtr inParamPtr, Boolean asynchFlag) -> None")}, #endif {"SPBPauseRecording", (PyCFunction)Snd_SPBPauseRecording, 1, - "(long inRefNum) -> None"}, + PyDoc_STR("(long inRefNum) -> None")}, {"SPBResumeRecording", (PyCFunction)Snd_SPBResumeRecording, 1, - "(long inRefNum) -> None"}, + PyDoc_STR("(long inRefNum) -> None")}, {"SPBStopRecording", (PyCFunction)Snd_SPBStopRecording, 1, - "(long inRefNum) -> None"}, + PyDoc_STR("(long inRefNum) -> None")}, {"SPBGetRecordingStatus", (PyCFunction)Snd_SPBGetRecordingStatus, 1, - "(long inRefNum) -> (short recordingStatus, short meterLevel, unsigned long totalSamplesToRecord, unsigned long numberOfSamplesRecorded, unsigned long totalMsecsToRecord, unsigned long numberOfMsecsRecorded)"}, + PyDoc_STR("(long inRefNum) -> (short recordingStatus, short meterLevel, unsigned long totalSamplesToRecord, unsigned long numberOfSamplesRecorded, unsigned long totalMsecsToRecord, unsigned long numberOfMsecsRecorded)")}, {"SPBGetDeviceInfo", (PyCFunction)Snd_SPBGetDeviceInfo, 1, - "(long inRefNum, OSType infoType, void * infoData) -> None"}, + PyDoc_STR("(long inRefNum, OSType infoType, void * infoData) -> None")}, {"SPBSetDeviceInfo", (PyCFunction)Snd_SPBSetDeviceInfo, 1, - "(long inRefNum, OSType infoType, void * infoData) -> None"}, + PyDoc_STR("(long inRefNum, OSType infoType, void * infoData) -> None")}, {"SPBMillisecondsToBytes", (PyCFunction)Snd_SPBMillisecondsToBytes, 1, - "(long inRefNum) -> (long milliseconds)"}, + PyDoc_STR("(long inRefNum) -> (long milliseconds)")}, {"SPBBytesToMilliseconds", (PyCFunction)Snd_SPBBytesToMilliseconds, 1, - "(long inRefNum) -> (long byteCount)"}, + PyDoc_STR("(long inRefNum) -> (long byteCount)")}, {NULL, NULL, 0} }; diff --git a/Mac/Modules/te/_TEmodule.c b/Mac/Modules/te/_TEmodule.c index c83eb84..1788620 100644 --- a/Mac/Modules/te/_TEmodule.c +++ b/Mac/Modules/te/_TEmodule.c @@ -774,79 +774,79 @@ static PyObject *TEObj_as_Resource(TEObject *_self, PyObject *_args) static PyMethodDef TEObj_methods[] = { {"TESetText", (PyCFunction)TEObj_TESetText, 1, - "(Buffer text) -> None"}, + PyDoc_STR("(Buffer text) -> None")}, {"TEGetText", (PyCFunction)TEObj_TEGetText, 1, - "() -> (CharsHandle _rv)"}, + PyDoc_STR("() -> (CharsHandle _rv)")}, {"TEIdle", (PyCFunction)TEObj_TEIdle, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"TESetSelect", (PyCFunction)TEObj_TESetSelect, 1, - "(long selStart, long selEnd) -> None"}, + PyDoc_STR("(long selStart, long selEnd) -> None")}, {"TEActivate", (PyCFunction)TEObj_TEActivate, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"TEDeactivate", (PyCFunction)TEObj_TEDeactivate, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"TEKey", (PyCFunction)TEObj_TEKey, 1, - "(CharParameter key) -> None"}, + PyDoc_STR("(CharParameter key) -> None")}, {"TECut", (PyCFunction)TEObj_TECut, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"TECopy", (PyCFunction)TEObj_TECopy, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"TEPaste", (PyCFunction)TEObj_TEPaste, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"TEDelete", (PyCFunction)TEObj_TEDelete, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"TEInsert", (PyCFunction)TEObj_TEInsert, 1, - "(Buffer text) -> None"}, + PyDoc_STR("(Buffer text) -> None")}, {"TESetAlignment", (PyCFunction)TEObj_TESetAlignment, 1, - "(short just) -> None"}, + PyDoc_STR("(short just) -> None")}, {"TEUpdate", (PyCFunction)TEObj_TEUpdate, 1, - "(Rect rUpdate) -> None"}, + PyDoc_STR("(Rect rUpdate) -> None")}, {"TEScroll", (PyCFunction)TEObj_TEScroll, 1, - "(short dh, short dv) -> None"}, + PyDoc_STR("(short dh, short dv) -> None")}, {"TESelView", (PyCFunction)TEObj_TESelView, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"TEPinScroll", (PyCFunction)TEObj_TEPinScroll, 1, - "(short dh, short dv) -> None"}, + PyDoc_STR("(short dh, short dv) -> None")}, {"TEAutoView", (PyCFunction)TEObj_TEAutoView, 1, - "(Boolean fAuto) -> None"}, + PyDoc_STR("(Boolean fAuto) -> None")}, {"TECalText", (PyCFunction)TEObj_TECalText, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"TEGetOffset", (PyCFunction)TEObj_TEGetOffset, 1, - "(Point pt) -> (short _rv)"}, + PyDoc_STR("(Point pt) -> (short _rv)")}, {"TEGetPoint", (PyCFunction)TEObj_TEGetPoint, 1, - "(short offset) -> (Point _rv)"}, + PyDoc_STR("(short offset) -> (Point _rv)")}, {"TEClick", (PyCFunction)TEObj_TEClick, 1, - "(Point pt, Boolean fExtend) -> None"}, + PyDoc_STR("(Point pt, Boolean fExtend) -> None")}, {"TESetStyleHandle", (PyCFunction)TEObj_TESetStyleHandle, 1, - "(TEStyleHandle theHandle) -> None"}, + PyDoc_STR("(TEStyleHandle theHandle) -> None")}, {"TEGetStyleHandle", (PyCFunction)TEObj_TEGetStyleHandle, 1, - "() -> (TEStyleHandle _rv)"}, + PyDoc_STR("() -> (TEStyleHandle _rv)")}, {"TEGetStyle", (PyCFunction)TEObj_TEGetStyle, 1, - "(short offset) -> (TextStyle theStyle, short lineHeight, short fontAscent)"}, + PyDoc_STR("(short offset) -> (TextStyle theStyle, short lineHeight, short fontAscent)")}, {"TEStylePaste", (PyCFunction)TEObj_TEStylePaste, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"TESetStyle", (PyCFunction)TEObj_TESetStyle, 1, - "(short mode, TextStyle newStyle, Boolean fRedraw) -> None"}, + PyDoc_STR("(short mode, TextStyle newStyle, Boolean fRedraw) -> None")}, {"TEReplaceStyle", (PyCFunction)TEObj_TEReplaceStyle, 1, - "(short mode, TextStyle oldStyle, TextStyle newStyle, Boolean fRedraw) -> None"}, + PyDoc_STR("(short mode, TextStyle oldStyle, TextStyle newStyle, Boolean fRedraw) -> None")}, {"TEGetStyleScrapHandle", (PyCFunction)TEObj_TEGetStyleScrapHandle, 1, - "() -> (StScrpHandle _rv)"}, + PyDoc_STR("() -> (StScrpHandle _rv)")}, {"TEStyleInsert", (PyCFunction)TEObj_TEStyleInsert, 1, - "(Buffer text, StScrpHandle hST) -> None"}, + PyDoc_STR("(Buffer text, StScrpHandle hST) -> None")}, {"TEGetHeight", (PyCFunction)TEObj_TEGetHeight, 1, - "(long endLine, long startLine) -> (long _rv)"}, + PyDoc_STR("(long endLine, long startLine) -> (long _rv)")}, {"TEContinuousStyle", (PyCFunction)TEObj_TEContinuousStyle, 1, - "(short mode, TextStyle aStyle) -> (Boolean _rv, short mode, TextStyle aStyle)"}, + PyDoc_STR("(short mode, TextStyle aStyle) -> (Boolean _rv, short mode, TextStyle aStyle)")}, {"TEUseStyleScrap", (PyCFunction)TEObj_TEUseStyleScrap, 1, - "(long rangeStart, long rangeEnd, StScrpHandle newStyles, Boolean fRedraw) -> None"}, + PyDoc_STR("(long rangeStart, long rangeEnd, StScrpHandle newStyles, Boolean fRedraw) -> None")}, {"TENumStyles", (PyCFunction)TEObj_TENumStyles, 1, - "(long rangeStart, long rangeEnd) -> (long _rv)"}, + PyDoc_STR("(long rangeStart, long rangeEnd) -> (long _rv)")}, {"TEFeatureFlag", (PyCFunction)TEObj_TEFeatureFlag, 1, - "(short feature, short action) -> (short _rv)"}, + PyDoc_STR("(short feature, short action) -> (short _rv)")}, {"TEGetHiliteRgn", (PyCFunction)TEObj_TEGetHiliteRgn, 1, - "(RgnHandle region) -> None"}, + PyDoc_STR("(RgnHandle region) -> None")}, {"as_Resource", (PyCFunction)TEObj_as_Resource, 1, - "() -> (Handle _rv)"}, + PyDoc_STR("() -> (Handle _rv)")}, {NULL, NULL, 0} }; @@ -1155,37 +1155,37 @@ static PyObject *TE_as_TE(PyObject *_self, PyObject *_args) static PyMethodDef TE_methods[] = { {"TEScrapHandle", (PyCFunction)TE_TEScrapHandle, 1, - "() -> (Handle _rv)"}, + PyDoc_STR("() -> (Handle _rv)")}, {"TEGetScrapLength", (PyCFunction)TE_TEGetScrapLength, 1, - "() -> (long _rv)"}, + PyDoc_STR("() -> (long _rv)")}, {"TENew", (PyCFunction)TE_TENew, 1, - "(Rect destRect, Rect viewRect) -> (TEHandle _rv)"}, + PyDoc_STR("(Rect destRect, Rect viewRect) -> (TEHandle _rv)")}, {"TETextBox", (PyCFunction)TE_TETextBox, 1, - "(Buffer text, Rect box, short just) -> None"}, + PyDoc_STR("(Buffer text, Rect box, short just) -> None")}, {"TEStyleNew", (PyCFunction)TE_TEStyleNew, 1, - "(Rect destRect, Rect viewRect) -> (TEHandle _rv)"}, + PyDoc_STR("(Rect destRect, Rect viewRect) -> (TEHandle _rv)")}, {"TESetScrapLength", (PyCFunction)TE_TESetScrapLength, 1, - "(long length) -> None"}, + PyDoc_STR("(long length) -> None")}, {"TEFromScrap", (PyCFunction)TE_TEFromScrap, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"TEToScrap", (PyCFunction)TE_TEToScrap, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #if TARGET_API_MAC_CARBON {"TEGetScrapHandle", (PyCFunction)TE_TEGetScrapHandle, 1, - "() -> (Handle _rv)"}, + PyDoc_STR("() -> (Handle _rv)")}, #endif #if TARGET_API_MAC_CARBON {"TESetScrapHandle", (PyCFunction)TE_TESetScrapHandle, 1, - "(Handle value) -> None"}, + PyDoc_STR("(Handle value) -> None")}, #endif {"LMGetWordRedraw", (PyCFunction)TE_LMGetWordRedraw, 1, - "() -> (UInt8 _rv)"}, + PyDoc_STR("() -> (UInt8 _rv)")}, {"LMSetWordRedraw", (PyCFunction)TE_LMSetWordRedraw, 1, - "(UInt8 value) -> None"}, + PyDoc_STR("(UInt8 value) -> None")}, {"as_TE", (PyCFunction)TE_as_TE, 1, - "(Handle h) -> (TEHandle _rv)"}, + PyDoc_STR("(Handle h) -> (TEHandle _rv)")}, {NULL, NULL, 0} }; diff --git a/Mac/Modules/win/_Winmodule.c b/Mac/Modules/win/_Winmodule.c index 30301e0..0685c26 100644 --- a/Mac/Modules/win/_Winmodule.c +++ b/Mac/Modules/win/_Winmodule.c @@ -2566,363 +2566,363 @@ static PyObject *WinObj_ShowWindow(WindowObject *_self, PyObject *_args) static PyMethodDef WinObj_methods[] = { {"GetWindowOwnerCount", (PyCFunction)WinObj_GetWindowOwnerCount, 1, - "() -> (UInt32 outCount)"}, + PyDoc_STR("() -> (UInt32 outCount)")}, {"CloneWindow", (PyCFunction)WinObj_CloneWindow, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #if !TARGET_API_MAC_OS8 {"GetWindowRetainCount", (PyCFunction)WinObj_GetWindowRetainCount, 1, - "() -> (ItemCount _rv)"}, + PyDoc_STR("() -> (ItemCount _rv)")}, #endif #if !TARGET_API_MAC_OS8 {"RetainWindow", (PyCFunction)WinObj_RetainWindow, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if !TARGET_API_MAC_OS8 {"ReleaseWindow", (PyCFunction)WinObj_ReleaseWindow, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if !TARGET_API_MAC_OS8 {"ReshapeCustomWindow", (PyCFunction)WinObj_ReshapeCustomWindow, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif {"GetWindowWidgetHilite", (PyCFunction)WinObj_GetWindowWidgetHilite, 1, - "() -> (WindowDefPartCode outHilite)"}, + PyDoc_STR("() -> (WindowDefPartCode outHilite)")}, {"GetWindowClass", (PyCFunction)WinObj_GetWindowClass, 1, - "() -> (WindowClass outClass)"}, + PyDoc_STR("() -> (WindowClass outClass)")}, {"GetWindowAttributes", (PyCFunction)WinObj_GetWindowAttributes, 1, - "() -> (WindowAttributes outAttributes)"}, + PyDoc_STR("() -> (WindowAttributes outAttributes)")}, #if !TARGET_API_MAC_OS8 {"ChangeWindowAttributes", (PyCFunction)WinObj_ChangeWindowAttributes, 1, - "(WindowAttributes setTheseAttributes, WindowAttributes clearTheseAttributes) -> None"}, + PyDoc_STR("(WindowAttributes setTheseAttributes, WindowAttributes clearTheseAttributes) -> None")}, #endif #if !TARGET_API_MAC_OS8 {"SetWindowClass", (PyCFunction)WinObj_SetWindowClass, 1, - "(WindowClass inWindowClass) -> None"}, + PyDoc_STR("(WindowClass inWindowClass) -> None")}, #endif #if !TARGET_API_MAC_OS8 {"SetWindowModality", (PyCFunction)WinObj_SetWindowModality, 1, - "(WindowModality inModalKind, WindowPtr inUnavailableWindow) -> None"}, + PyDoc_STR("(WindowModality inModalKind, WindowPtr inUnavailableWindow) -> None")}, #endif #if !TARGET_API_MAC_OS8 {"GetWindowModality", (PyCFunction)WinObj_GetWindowModality, 1, - "() -> (WindowModality outModalKind, WindowPtr outUnavailableWindow)"}, + PyDoc_STR("() -> (WindowModality outModalKind, WindowPtr outUnavailableWindow)")}, #endif #if !TARGET_API_MAC_CARBON {"SetWinColor", (PyCFunction)WinObj_SetWinColor, 1, - "(WCTabHandle newColorTable) -> None"}, + PyDoc_STR("(WCTabHandle newColorTable) -> None")}, #endif {"SetWindowContentColor", (PyCFunction)WinObj_SetWindowContentColor, 1, - "(RGBColor color) -> None"}, + PyDoc_STR("(RGBColor color) -> None")}, {"GetWindowContentColor", (PyCFunction)WinObj_GetWindowContentColor, 1, - "() -> (RGBColor color)"}, + PyDoc_STR("() -> (RGBColor color)")}, {"GetWindowContentPattern", (PyCFunction)WinObj_GetWindowContentPattern, 1, - "(PixPatHandle outPixPat) -> None"}, + PyDoc_STR("(PixPatHandle outPixPat) -> None")}, {"SetWindowContentPattern", (PyCFunction)WinObj_SetWindowContentPattern, 1, - "(PixPatHandle pixPat) -> None"}, + PyDoc_STR("(PixPatHandle pixPat) -> None")}, #if !TARGET_API_MAC_OS8 {"ScrollWindowRect", (PyCFunction)WinObj_ScrollWindowRect, 1, - "(Rect inScrollRect, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None"}, + PyDoc_STR("(Rect inScrollRect, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None")}, #endif #if !TARGET_API_MAC_OS8 {"ScrollWindowRegion", (PyCFunction)WinObj_ScrollWindowRegion, 1, - "(RgnHandle inScrollRgn, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None"}, + PyDoc_STR("(RgnHandle inScrollRgn, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None")}, #endif {"ClipAbove", (PyCFunction)WinObj_ClipAbove, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #if !TARGET_API_MAC_CARBON {"SaveOld", (PyCFunction)WinObj_SaveOld, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if !TARGET_API_MAC_CARBON {"DrawNew", (PyCFunction)WinObj_DrawNew, 1, - "(Boolean update) -> None"}, + PyDoc_STR("(Boolean update) -> None")}, #endif {"PaintOne", (PyCFunction)WinObj_PaintOne, 1, - "(RgnHandle clobberedRgn) -> None"}, + PyDoc_STR("(RgnHandle clobberedRgn) -> None")}, {"PaintBehind", (PyCFunction)WinObj_PaintBehind, 1, - "(RgnHandle clobberedRgn) -> None"}, + PyDoc_STR("(RgnHandle clobberedRgn) -> None")}, {"CalcVis", (PyCFunction)WinObj_CalcVis, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"CalcVisBehind", (PyCFunction)WinObj_CalcVisBehind, 1, - "(RgnHandle clobberedRgn) -> None"}, + PyDoc_STR("(RgnHandle clobberedRgn) -> None")}, {"BringToFront", (PyCFunction)WinObj_BringToFront, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"SendBehind", (PyCFunction)WinObj_SendBehind, 1, - "(WindowPtr behindWindow) -> None"}, + PyDoc_STR("(WindowPtr behindWindow) -> None")}, {"SelectWindow", (PyCFunction)WinObj_SelectWindow, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #if !TARGET_API_MAC_OS8 {"GetNextWindowOfClass", (PyCFunction)WinObj_GetNextWindowOfClass, 1, - "(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)"}, + PyDoc_STR("(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)")}, #endif #if !TARGET_API_MAC_OS8 {"SetWindowAlternateTitle", (PyCFunction)WinObj_SetWindowAlternateTitle, 1, - "(CFStringRef inTitle) -> None"}, + PyDoc_STR("(CFStringRef inTitle) -> None")}, #endif #if !TARGET_API_MAC_OS8 {"CopyWindowAlternateTitle", (PyCFunction)WinObj_CopyWindowAlternateTitle, 1, - "() -> (CFStringRef outTitle)"}, + PyDoc_STR("() -> (CFStringRef outTitle)")}, #endif #if !TARGET_API_MAC_CARBON {"IsValidWindowPtr", (PyCFunction)WinObj_IsValidWindowPtr, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, #endif {"HiliteWindow", (PyCFunction)WinObj_HiliteWindow, 1, - "(Boolean fHilite) -> None"}, + PyDoc_STR("(Boolean fHilite) -> None")}, {"SetWRefCon", (PyCFunction)WinObj_SetWRefCon, 1, - "(long data) -> None"}, + PyDoc_STR("(long data) -> None")}, {"GetWRefCon", (PyCFunction)WinObj_GetWRefCon, 1, - "() -> (long _rv)"}, + PyDoc_STR("() -> (long _rv)")}, {"SetWindowPic", (PyCFunction)WinObj_SetWindowPic, 1, - "(PicHandle pic) -> None"}, + PyDoc_STR("(PicHandle pic) -> None")}, {"GetWindowPic", (PyCFunction)WinObj_GetWindowPic, 1, - "() -> (PicHandle _rv)"}, + PyDoc_STR("() -> (PicHandle _rv)")}, {"GetWVariant", (PyCFunction)WinObj_GetWVariant, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, {"GetWindowFeatures", (PyCFunction)WinObj_GetWindowFeatures, 1, - "() -> (UInt32 outFeatures)"}, + PyDoc_STR("() -> (UInt32 outFeatures)")}, {"GetWindowRegion", (PyCFunction)WinObj_GetWindowRegion, 1, - "(WindowRegionCode inRegionCode, RgnHandle ioWinRgn) -> None"}, + PyDoc_STR("(WindowRegionCode inRegionCode, RgnHandle ioWinRgn) -> None")}, {"GetWindowStructureWidths", (PyCFunction)WinObj_GetWindowStructureWidths, 1, - "() -> (Rect outRect)"}, + PyDoc_STR("() -> (Rect outRect)")}, {"BeginUpdate", (PyCFunction)WinObj_BeginUpdate, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"EndUpdate", (PyCFunction)WinObj_EndUpdate, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"InvalWindowRgn", (PyCFunction)WinObj_InvalWindowRgn, 1, - "(RgnHandle region) -> None"}, + PyDoc_STR("(RgnHandle region) -> None")}, {"InvalWindowRect", (PyCFunction)WinObj_InvalWindowRect, 1, - "(Rect bounds) -> None"}, + PyDoc_STR("(Rect bounds) -> None")}, {"ValidWindowRgn", (PyCFunction)WinObj_ValidWindowRgn, 1, - "(RgnHandle region) -> None"}, + PyDoc_STR("(RgnHandle region) -> None")}, {"ValidWindowRect", (PyCFunction)WinObj_ValidWindowRect, 1, - "(Rect bounds) -> None"}, + PyDoc_STR("(Rect bounds) -> None")}, {"DrawGrowIcon", (PyCFunction)WinObj_DrawGrowIcon, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"SetWTitle", (PyCFunction)WinObj_SetWTitle, 1, - "(Str255 title) -> None"}, + PyDoc_STR("(Str255 title) -> None")}, {"GetWTitle", (PyCFunction)WinObj_GetWTitle, 1, - "() -> (Str255 title)"}, + PyDoc_STR("() -> (Str255 title)")}, #if !TARGET_API_MAC_OS8 {"SetWindowTitleWithCFString", (PyCFunction)WinObj_SetWindowTitleWithCFString, 1, - "(CFStringRef inString) -> None"}, + PyDoc_STR("(CFStringRef inString) -> None")}, #endif #if !TARGET_API_MAC_OS8 {"CopyWindowTitleAsCFString", (PyCFunction)WinObj_CopyWindowTitleAsCFString, 1, - "() -> (CFStringRef outString)"}, + PyDoc_STR("() -> (CFStringRef outString)")}, #endif {"SetWindowProxyFSSpec", (PyCFunction)WinObj_SetWindowProxyFSSpec, 1, - "(FSSpec inFile) -> None"}, + PyDoc_STR("(FSSpec inFile) -> None")}, {"GetWindowProxyFSSpec", (PyCFunction)WinObj_GetWindowProxyFSSpec, 1, - "() -> (FSSpec outFile)"}, + PyDoc_STR("() -> (FSSpec outFile)")}, {"SetWindowProxyAlias", (PyCFunction)WinObj_SetWindowProxyAlias, 1, - "(AliasHandle alias) -> None"}, + PyDoc_STR("(AliasHandle alias) -> None")}, {"GetWindowProxyAlias", (PyCFunction)WinObj_GetWindowProxyAlias, 1, - "() -> (AliasHandle alias)"}, + PyDoc_STR("() -> (AliasHandle alias)")}, {"SetWindowProxyCreatorAndType", (PyCFunction)WinObj_SetWindowProxyCreatorAndType, 1, - "(OSType fileCreator, OSType fileType, SInt16 vRefNum) -> None"}, + PyDoc_STR("(OSType fileCreator, OSType fileType, SInt16 vRefNum) -> None")}, {"GetWindowProxyIcon", (PyCFunction)WinObj_GetWindowProxyIcon, 1, - "() -> (IconRef outIcon)"}, + PyDoc_STR("() -> (IconRef outIcon)")}, {"SetWindowProxyIcon", (PyCFunction)WinObj_SetWindowProxyIcon, 1, - "(IconRef icon) -> None"}, + PyDoc_STR("(IconRef icon) -> None")}, {"RemoveWindowProxy", (PyCFunction)WinObj_RemoveWindowProxy, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"BeginWindowProxyDrag", (PyCFunction)WinObj_BeginWindowProxyDrag, 1, - "(RgnHandle outDragOutlineRgn) -> (DragReference outNewDrag)"}, + PyDoc_STR("(RgnHandle outDragOutlineRgn) -> (DragReference outNewDrag)")}, {"EndWindowProxyDrag", (PyCFunction)WinObj_EndWindowProxyDrag, 1, - "(DragReference theDrag) -> None"}, + PyDoc_STR("(DragReference theDrag) -> None")}, {"TrackWindowProxyFromExistingDrag", (PyCFunction)WinObj_TrackWindowProxyFromExistingDrag, 1, - "(Point startPt, DragReference drag, RgnHandle inDragOutlineRgn) -> None"}, + PyDoc_STR("(Point startPt, DragReference drag, RgnHandle inDragOutlineRgn) -> None")}, {"TrackWindowProxyDrag", (PyCFunction)WinObj_TrackWindowProxyDrag, 1, - "(Point startPt) -> None"}, + PyDoc_STR("(Point startPt) -> None")}, {"IsWindowModified", (PyCFunction)WinObj_IsWindowModified, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, {"SetWindowModified", (PyCFunction)WinObj_SetWindowModified, 1, - "(Boolean modified) -> None"}, + PyDoc_STR("(Boolean modified) -> None")}, {"IsWindowPathSelectClick", (PyCFunction)WinObj_IsWindowPathSelectClick, 1, - "(EventRecord event) -> (Boolean _rv)"}, + PyDoc_STR("(EventRecord event) -> (Boolean _rv)")}, {"WindowPathSelect", (PyCFunction)WinObj_WindowPathSelect, 1, - "(MenuHandle menu) -> (SInt32 outMenuResult)"}, + PyDoc_STR("(MenuHandle menu) -> (SInt32 outMenuResult)")}, {"HiliteWindowFrameForDrag", (PyCFunction)WinObj_HiliteWindowFrameForDrag, 1, - "(Boolean hilited) -> None"}, + PyDoc_STR("(Boolean hilited) -> None")}, {"TransitionWindow", (PyCFunction)WinObj_TransitionWindow, 1, - "(WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None"}, + PyDoc_STR("(WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None")}, #if TARGET_API_MAC_OSX {"TransitionWindowAndParent", (PyCFunction)WinObj_TransitionWindowAndParent, 1, - "(WindowPtr parentWindow, WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None"}, + PyDoc_STR("(WindowPtr parentWindow, WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None")}, #endif {"MacMoveWindow", (PyCFunction)WinObj_MacMoveWindow, 1, - "(short hGlobal, short vGlobal, Boolean front) -> None"}, + PyDoc_STR("(short hGlobal, short vGlobal, Boolean front) -> None")}, {"SizeWindow", (PyCFunction)WinObj_SizeWindow, 1, - "(short w, short h, Boolean fUpdate) -> None"}, + PyDoc_STR("(short w, short h, Boolean fUpdate) -> None")}, {"GrowWindow", (PyCFunction)WinObj_GrowWindow, 1, - "(Point startPt, Rect bBox) -> (long _rv)"}, + PyDoc_STR("(Point startPt, Rect bBox) -> (long _rv)")}, {"DragWindow", (PyCFunction)WinObj_DragWindow, 1, - "(Point startPt, Rect boundsRect) -> None"}, + PyDoc_STR("(Point startPt, Rect boundsRect) -> None")}, {"ZoomWindow", (PyCFunction)WinObj_ZoomWindow, 1, - "(WindowPartCode partCode, Boolean front) -> None"}, + PyDoc_STR("(WindowPartCode partCode, Boolean front) -> None")}, {"IsWindowCollapsable", (PyCFunction)WinObj_IsWindowCollapsable, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, {"IsWindowCollapsed", (PyCFunction)WinObj_IsWindowCollapsed, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, {"CollapseWindow", (PyCFunction)WinObj_CollapseWindow, 1, - "(Boolean collapse) -> None"}, + PyDoc_STR("(Boolean collapse) -> None")}, {"GetWindowBounds", (PyCFunction)WinObj_GetWindowBounds, 1, - "(WindowRegionCode regionCode) -> (Rect globalBounds)"}, + PyDoc_STR("(WindowRegionCode regionCode) -> (Rect globalBounds)")}, {"ResizeWindow", (PyCFunction)WinObj_ResizeWindow, 1, - "(Point startPoint, Rect sizeConstraints) -> (Boolean _rv, Rect newContentRect)"}, + PyDoc_STR("(Point startPoint, Rect sizeConstraints) -> (Boolean _rv, Rect newContentRect)")}, {"SetWindowBounds", (PyCFunction)WinObj_SetWindowBounds, 1, - "(WindowRegionCode regionCode, Rect globalBounds) -> None"}, + PyDoc_STR("(WindowRegionCode regionCode, Rect globalBounds) -> None")}, {"RepositionWindow", (PyCFunction)WinObj_RepositionWindow, 1, - "(WindowPtr parentWindow, WindowPositionMethod method) -> None"}, + PyDoc_STR("(WindowPtr parentWindow, WindowPositionMethod method) -> None")}, {"MoveWindowStructure", (PyCFunction)WinObj_MoveWindowStructure, 1, - "(short hGlobal, short vGlobal) -> None"}, + PyDoc_STR("(short hGlobal, short vGlobal) -> None")}, {"IsWindowInStandardState", (PyCFunction)WinObj_IsWindowInStandardState, 1, - "() -> (Boolean _rv, Point idealSize, Rect idealStandardState)"}, + PyDoc_STR("() -> (Boolean _rv, Point idealSize, Rect idealStandardState)")}, {"ZoomWindowIdeal", (PyCFunction)WinObj_ZoomWindowIdeal, 1, - "(WindowPartCode partCode) -> (Point ioIdealSize)"}, + PyDoc_STR("(WindowPartCode partCode) -> (Point ioIdealSize)")}, {"GetWindowIdealUserState", (PyCFunction)WinObj_GetWindowIdealUserState, 1, - "() -> (Rect userState)"}, + PyDoc_STR("() -> (Rect userState)")}, {"SetWindowIdealUserState", (PyCFunction)WinObj_SetWindowIdealUserState, 1, - "(Rect userState) -> None"}, + PyDoc_STR("(Rect userState) -> None")}, #if !TARGET_API_MAC_OS8 {"GetWindowGreatestAreaDevice", (PyCFunction)WinObj_GetWindowGreatestAreaDevice, 1, - "(WindowRegionCode inRegion) -> (GDHandle outGreatestDevice, Rect outGreatestDeviceRect)"}, + PyDoc_STR("(WindowRegionCode inRegion) -> (GDHandle outGreatestDevice, Rect outGreatestDeviceRect)")}, #endif #if !TARGET_API_MAC_OS8 {"ConstrainWindowToScreen", (PyCFunction)WinObj_ConstrainWindowToScreen, 1, - "(WindowRegionCode inRegionCode, WindowConstrainOptions inOptions, Rect inScreenRect) -> (Rect outStructure)"}, + PyDoc_STR("(WindowRegionCode inRegionCode, WindowConstrainOptions inOptions, Rect inScreenRect) -> (Rect outStructure)")}, #endif {"HideWindow", (PyCFunction)WinObj_HideWindow, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"MacShowWindow", (PyCFunction)WinObj_MacShowWindow, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"ShowHide", (PyCFunction)WinObj_ShowHide, 1, - "(Boolean showFlag) -> None"}, + PyDoc_STR("(Boolean showFlag) -> None")}, {"MacIsWindowVisible", (PyCFunction)WinObj_MacIsWindowVisible, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, #if !TARGET_API_MAC_OS8 {"ShowSheetWindow", (PyCFunction)WinObj_ShowSheetWindow, 1, - "(WindowPtr inParentWindow) -> None"}, + PyDoc_STR("(WindowPtr inParentWindow) -> None")}, #endif #if !TARGET_API_MAC_OS8 {"HideSheetWindow", (PyCFunction)WinObj_HideSheetWindow, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if !TARGET_API_MAC_OS8 {"GetSheetWindowParent", (PyCFunction)WinObj_GetSheetWindowParent, 1, - "() -> (WindowPtr outParentWindow)"}, + PyDoc_STR("() -> (WindowPtr outParentWindow)")}, #endif #if !TARGET_API_MAC_OS8 {"GetWindowPropertyAttributes", (PyCFunction)WinObj_GetWindowPropertyAttributes, 1, - "(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)"}, + PyDoc_STR("(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)")}, #endif #if !TARGET_API_MAC_OS8 {"ChangeWindowPropertyAttributes", (PyCFunction)WinObj_ChangeWindowPropertyAttributes, 1, - "(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None"}, + PyDoc_STR("(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None")}, #endif {"TrackBox", (PyCFunction)WinObj_TrackBox, 1, - "(Point thePt, WindowPartCode partCode) -> (Boolean _rv)"}, + PyDoc_STR("(Point thePt, WindowPartCode partCode) -> (Boolean _rv)")}, {"TrackGoAway", (PyCFunction)WinObj_TrackGoAway, 1, - "(Point thePt) -> (Boolean _rv)"}, + PyDoc_STR("(Point thePt) -> (Boolean _rv)")}, #if !TARGET_API_MAC_CARBON {"GetAuxWin", (PyCFunction)WinObj_GetAuxWin, 1, - "() -> (Boolean _rv, AuxWinHandle awHndl)"}, + PyDoc_STR("() -> (Boolean _rv, AuxWinHandle awHndl)")}, #endif #if !TARGET_API_MAC_CARBON {"GetWindowGoAwayFlag", (PyCFunction)WinObj_GetWindowGoAwayFlag, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, #endif #if !TARGET_API_MAC_CARBON {"GetWindowSpareFlag", (PyCFunction)WinObj_GetWindowSpareFlag, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, #endif {"GetWindowPort", (PyCFunction)WinObj_GetWindowPort, 1, - "() -> (CGrafPtr _rv)"}, + PyDoc_STR("() -> (CGrafPtr _rv)")}, {"GetWindowKind", (PyCFunction)WinObj_GetWindowKind, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, {"IsWindowHilited", (PyCFunction)WinObj_IsWindowHilited, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, #if !TARGET_API_MAC_OS8 {"IsWindowUpdatePending", (PyCFunction)WinObj_IsWindowUpdatePending, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, #endif {"MacGetNextWindow", (PyCFunction)WinObj_MacGetNextWindow, 1, - "() -> (WindowPtr _rv)"}, + PyDoc_STR("() -> (WindowPtr _rv)")}, {"GetWindowStandardState", (PyCFunction)WinObj_GetWindowStandardState, 1, - "() -> (Rect rect)"}, + PyDoc_STR("() -> (Rect rect)")}, {"GetWindowUserState", (PyCFunction)WinObj_GetWindowUserState, 1, - "() -> (Rect rect)"}, + PyDoc_STR("() -> (Rect rect)")}, {"SetWindowKind", (PyCFunction)WinObj_SetWindowKind, 1, - "(short kind) -> None"}, + PyDoc_STR("(short kind) -> None")}, {"SetWindowStandardState", (PyCFunction)WinObj_SetWindowStandardState, 1, - "(Rect rect) -> None"}, + PyDoc_STR("(Rect rect) -> None")}, {"SetWindowUserState", (PyCFunction)WinObj_SetWindowUserState, 1, - "(Rect rect) -> None"}, + PyDoc_STR("(Rect rect) -> None")}, {"SetPortWindowPort", (PyCFunction)WinObj_SetPortWindowPort, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"GetWindowPortBounds", (PyCFunction)WinObj_GetWindowPortBounds, 1, - "() -> (Rect bounds)"}, + PyDoc_STR("() -> (Rect bounds)")}, {"IsWindowVisible", (PyCFunction)WinObj_IsWindowVisible, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, #if !TARGET_API_MAC_CARBON {"GetWindowZoomFlag", (PyCFunction)WinObj_GetWindowZoomFlag, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, #endif {"GetWindowStructureRgn", (PyCFunction)WinObj_GetWindowStructureRgn, 1, - "(RgnHandle r) -> None"}, + PyDoc_STR("(RgnHandle r) -> None")}, {"GetWindowContentRgn", (PyCFunction)WinObj_GetWindowContentRgn, 1, - "(RgnHandle r) -> None"}, + PyDoc_STR("(RgnHandle r) -> None")}, {"GetWindowUpdateRgn", (PyCFunction)WinObj_GetWindowUpdateRgn, 1, - "(RgnHandle r) -> None"}, + PyDoc_STR("(RgnHandle r) -> None")}, #if !TARGET_API_MAC_CARBON {"GetWindowTitleWidth", (PyCFunction)WinObj_GetWindowTitleWidth, 1, - "() -> (short _rv)"}, + PyDoc_STR("() -> (short _rv)")}, #endif {"GetNextWindow", (PyCFunction)WinObj_GetNextWindow, 1, - "() -> (WindowPtr _rv)"}, + PyDoc_STR("() -> (WindowPtr _rv)")}, #if !TARGET_API_MAC_CARBON {"CloseWindow", (PyCFunction)WinObj_CloseWindow, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif {"MoveWindow", (PyCFunction)WinObj_MoveWindow, 1, - "(short hGlobal, short vGlobal, Boolean front) -> None"}, + PyDoc_STR("(short hGlobal, short vGlobal, Boolean front) -> None")}, {"ShowWindow", (PyCFunction)WinObj_ShowWindow, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {NULL, NULL, 0} }; @@ -3658,118 +3658,118 @@ static PyObject *Win_FindWindow(PyObject *_self, PyObject *_args) static PyMethodDef Win_methods[] = { {"GetNewCWindow", (PyCFunction)Win_GetNewCWindow, 1, - "(short windowID, WindowPtr behind) -> (WindowPtr _rv)"}, + PyDoc_STR("(short windowID, WindowPtr behind) -> (WindowPtr _rv)")}, {"NewWindow", (PyCFunction)Win_NewWindow, 1, - "(Rect boundsRect, Str255 title, Boolean visible, short theProc, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)"}, + PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, short theProc, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)")}, {"GetNewWindow", (PyCFunction)Win_GetNewWindow, 1, - "(short windowID, WindowPtr behind) -> (WindowPtr _rv)"}, + PyDoc_STR("(short windowID, WindowPtr behind) -> (WindowPtr _rv)")}, {"NewCWindow", (PyCFunction)Win_NewCWindow, 1, - "(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)"}, + PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)")}, {"CreateNewWindow", (PyCFunction)Win_CreateNewWindow, 1, - "(WindowClass windowClass, WindowAttributes attributes, Rect contentBounds) -> (WindowPtr outWindow)"}, + PyDoc_STR("(WindowClass windowClass, WindowAttributes attributes, Rect contentBounds) -> (WindowPtr outWindow)")}, {"CreateWindowFromResource", (PyCFunction)Win_CreateWindowFromResource, 1, - "(SInt16 resID) -> (WindowPtr outWindow)"}, + PyDoc_STR("(SInt16 resID) -> (WindowPtr outWindow)")}, {"ShowFloatingWindows", (PyCFunction)Win_ShowFloatingWindows, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"HideFloatingWindows", (PyCFunction)Win_HideFloatingWindows, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, {"AreFloatingWindowsVisible", (PyCFunction)Win_AreFloatingWindowsVisible, 1, - "() -> (Boolean _rv)"}, + PyDoc_STR("() -> (Boolean _rv)")}, #if !TARGET_API_MAC_CARBON {"SetDeskCPat", (PyCFunction)Win_SetDeskCPat, 1, - "(PixPatHandle deskPixPat) -> None"}, + PyDoc_STR("(PixPatHandle deskPixPat) -> None")}, #endif {"CheckUpdate", (PyCFunction)Win_CheckUpdate, 1, - "() -> (Boolean _rv, EventRecord theEvent)"}, + PyDoc_STR("() -> (Boolean _rv, EventRecord theEvent)")}, {"MacFindWindow", (PyCFunction)Win_MacFindWindow, 1, - "(Point thePoint) -> (WindowPartCode _rv, WindowPtr window)"}, + PyDoc_STR("(Point thePoint) -> (WindowPartCode _rv, WindowPtr window)")}, {"FrontWindow", (PyCFunction)Win_FrontWindow, 1, - "() -> (WindowPtr _rv)"}, + PyDoc_STR("() -> (WindowPtr _rv)")}, {"FrontNonFloatingWindow", (PyCFunction)Win_FrontNonFloatingWindow, 1, - "() -> (WindowPtr _rv)"}, + PyDoc_STR("() -> (WindowPtr _rv)")}, #if !TARGET_API_MAC_OS8 {"GetFrontWindowOfClass", (PyCFunction)Win_GetFrontWindowOfClass, 1, - "(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)"}, + PyDoc_STR("(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)")}, #endif #if !TARGET_API_MAC_OS8 {"FindWindowOfClass", (PyCFunction)Win_FindWindowOfClass, 1, - "(Point where, WindowClass inWindowClass) -> (WindowPtr outWindow, WindowPartCode outWindowPart)"}, + PyDoc_STR("(Point where, WindowClass inWindowClass) -> (WindowPtr outWindow, WindowPartCode outWindowPart)")}, #endif #if !TARGET_API_MAC_OS8 {"CreateStandardWindowMenu", (PyCFunction)Win_CreateStandardWindowMenu, 1, - "(OptionBits inOptions) -> (MenuHandle outMenu)"}, + PyDoc_STR("(OptionBits inOptions) -> (MenuHandle outMenu)")}, #endif #if !TARGET_API_MAC_CARBON {"InitWindows", (PyCFunction)Win_InitWindows, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if !TARGET_API_MAC_CARBON {"GetWMgrPort", (PyCFunction)Win_GetWMgrPort, 1, - "() -> (GrafPtr wPort)"}, + PyDoc_STR("() -> (GrafPtr wPort)")}, #endif #if !TARGET_API_MAC_CARBON {"GetCWMgrPort", (PyCFunction)Win_GetCWMgrPort, 1, - "() -> (CGrafPtr wMgrCPort)"}, + PyDoc_STR("() -> (CGrafPtr wMgrCPort)")}, #endif #if !TARGET_API_MAC_CARBON {"InitFloatingWindows", (PyCFunction)Win_InitFloatingWindows, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if !TARGET_API_MAC_CARBON {"InvalRect", (PyCFunction)Win_InvalRect, 1, - "(Rect badRect) -> None"}, + PyDoc_STR("(Rect badRect) -> None")}, #endif #if !TARGET_API_MAC_CARBON {"InvalRgn", (PyCFunction)Win_InvalRgn, 1, - "(RgnHandle badRgn) -> None"}, + PyDoc_STR("(RgnHandle badRgn) -> None")}, #endif #if !TARGET_API_MAC_CARBON {"ValidRect", (PyCFunction)Win_ValidRect, 1, - "(Rect goodRect) -> None"}, + PyDoc_STR("(Rect goodRect) -> None")}, #endif #if !TARGET_API_MAC_CARBON {"ValidRgn", (PyCFunction)Win_ValidRgn, 1, - "(RgnHandle goodRgn) -> None"}, + PyDoc_STR("(RgnHandle goodRgn) -> None")}, #endif {"CollapseAllWindows", (PyCFunction)Win_CollapseAllWindows, 1, - "(Boolean collapse) -> None"}, + PyDoc_STR("(Boolean collapse) -> None")}, #if !TARGET_API_MAC_OS8 {"GetAvailableWindowPositioningBounds", (PyCFunction)Win_GetAvailableWindowPositioningBounds, 1, - "(GDHandle inDevice) -> (Rect availableRect)"}, + PyDoc_STR("(GDHandle inDevice) -> (Rect availableRect)")}, #endif #if !TARGET_API_MAC_OS8 {"DisableScreenUpdates", (PyCFunction)Win_DisableScreenUpdates, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif #if !TARGET_API_MAC_OS8 {"EnableScreenUpdates", (PyCFunction)Win_EnableScreenUpdates, 1, - "() -> None"}, + PyDoc_STR("() -> None")}, #endif {"PinRect", (PyCFunction)Win_PinRect, 1, - "(Rect theRect, Point thePt) -> (long _rv)"}, + PyDoc_STR("(Rect theRect, Point thePt) -> (long _rv)")}, {"GetGrayRgn", (PyCFunction)Win_GetGrayRgn, 1, - "() -> (RgnHandle _rv)"}, + PyDoc_STR("() -> (RgnHandle _rv)")}, {"GetWindowFromPort", (PyCFunction)Win_GetWindowFromPort, 1, - "(CGrafPtr port) -> (WindowPtr _rv)"}, + PyDoc_STR("(CGrafPtr port) -> (WindowPtr _rv)")}, {"WhichWindow", (PyCFunction)Win_WhichWindow, 1, - "Resolve an integer WindowPtr address to a Window object"}, + PyDoc_STR("Resolve an integer WindowPtr address to a Window object")}, {"FindWindow", (PyCFunction)Win_FindWindow, 1, - "(Point thePoint) -> (short _rv, WindowPtr theWindow)"}, + PyDoc_STR("(Point thePoint) -> (short _rv, WindowPtr theWindow)")}, {NULL, NULL, 0} }; -- cgit v0.12