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}
};
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}
};
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}
};
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}
};
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}
};
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}
};
static PyMethodDef EventLoopRef_methods[] = {
{"QuitEventLoop", (PyCFunction)EventLoopRef_QuitEventLoop, 1,
- "() -> None"},
+ PyDoc_STR("() -> None")},
{NULL, NULL, 0}
};
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}
};
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}
};
static PyMethodDef EventHandlerCallRef_methods[] = {
{"CallNextEventHandler", (PyCFunction)EventHandlerCallRef_CallNextEventHandler, 1,
- "(EventRef inEvent) -> None"},
+ PyDoc_STR("(EventRef inEvent) -> None")},
{NULL, NULL, 0}
};
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}
};
static PyMethodDef EventHotKeyRef_methods[] = {
{"UnregisterEventHotKey", (PyCFunction)EventHotKeyRef_UnregisterEventHotKey, 1,
- "() -> None"},
+ PyDoc_STR("() -> None")},
{NULL, NULL, 0}
};
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}
};
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}
};
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}
};
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}
};
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}
};
static PyMethodDef CFMutableDictionaryRefObj_methods[] = {
{"CFDictionaryRemoveAllValues", (PyCFunction)CFMutableDictionaryRefObj_CFDictionaryRemoveAllValues, 1,
- "() -> None"},
+ PyDoc_STR("() -> None")},
{NULL, NULL, 0}
};
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}
};
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}
};
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}
};
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}
};
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}
};
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}
};
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}
};
static PyMethodDef CG_methods[] = {
{"CreateCGContextForPort", (PyCFunction)CG_CreateCGContextForPort, 1,
- "(CGrafPtr) -> CGContextRef"},
+ PyDoc_STR("(CGrafPtr) -> CGContextRef")},
{NULL, NULL, 0}
};
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}
};
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}
};
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}
};
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}
};
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}
};
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}
};
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}
};
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}
};
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}
};
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}
};
#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}
};
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}
};
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}
};
static PyMethodDef IBCarbon_methods[] = {
{"CreateNibReference", (PyCFunction)IBCarbon_CreateNibReference, 1,
- "(CFStringRef inNibName) -> (IBNibRef outNibRef)"},
+ PyDoc_STR("(CFStringRef inNibName) -> (IBNibRef outNibRef)")},
{NULL, NULL, 0}
};
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}
};
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}
};
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}
};
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}
};
#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}
};
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}
};
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}
};
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}
};
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}
};
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}
};
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}
};
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}
};
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}
};
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}
};
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}
};
#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}
};
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}
};
#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}
};
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}
};
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}
};
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}
};
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}
};
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}
};
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}
};
projects / python / commitdiff