mirrors
/
cpython
mirror of https://github.com/python/cpython.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Regenerated with PyDoc_STR() around docstrings.

This commit is contained in:
Jack Jansen 2002-08-16 09:09:31 +00:00
parent 44b99e0a1f
commit 49931887d7
23 changed files with 2151 additions and 2151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
Mac/Modules/ae/_AEmodule.c
View File

@ -759,64 +759,64 @@ static PyObject *AEDesc_AEResolve(AEDescObject *_self, PyObject *_args)
static PyMethodDef AEDesc_methods[] = {
{"AECoerceDesc", (PyCFunction)AEDesc_AECoerceDesc, 1,
"(DescType toType) -> (AEDesc result)"},
PyDoc_STR("(DescType toType) -> (AEDesc result)")},
{"AEDuplicateDesc", (PyCFunction)AEDesc_AEDuplicateDesc, 1,
"() -> (AEDesc result)"},
PyDoc_STR("() -> (AEDesc result)")},
{"AECountItems", (PyCFunction)AEDesc_AECountItems, 1,
"() -> (long theCount)"},
PyDoc_STR("() -> (long theCount)")},
{"AEPutPtr", (PyCFunction)AEDesc_AEPutPtr, 1,
"(long index, DescType typeCode, Buffer dataPtr) -> None"},
PyDoc_STR("(long index, DescType typeCode, Buffer dataPtr) -> None")},
{"AEPutDesc", (PyCFunction)AEDesc_AEPutDesc, 1,
"(long index, AEDesc theAEDesc) -> None"},
PyDoc_STR("(long index, AEDesc theAEDesc) -> None")},
{"AEGetNthPtr", (PyCFunction)AEDesc_AEGetNthPtr, 1,
"(long index, DescType desiredType, Buffer dataPtr) -> (AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr)"},
PyDoc_STR("(long index, DescType desiredType, Buffer dataPtr) -> (AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr)")},
{"AEGetNthDesc", (PyCFunction)AEDesc_AEGetNthDesc, 1,
"(long index, DescType desiredType) -> (AEKeyword theAEKeyword, AEDesc result)"},
PyDoc_STR("(long index, DescType desiredType) -> (AEKeyword theAEKeyword, AEDesc result)")},
{"AESizeOfNthItem", (PyCFunction)AEDesc_AESizeOfNthItem, 1,
"(long index) -> (DescType typeCode, Size dataSize)"},
PyDoc_STR("(long index) -> (DescType typeCode, Size dataSize)")},
{"AEDeleteItem", (PyCFunction)AEDesc_AEDeleteItem, 1,
"(long index) -> None"},
PyDoc_STR("(long index) -> None")},
{"AEPutParamPtr", (PyCFunction)AEDesc_AEPutParamPtr, 1,
"(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None"},
PyDoc_STR("(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None")},
{"AEPutParamDesc", (PyCFunction)AEDesc_AEPutParamDesc, 1,
"(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None"},
PyDoc_STR("(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None")},
{"AEGetParamPtr", (PyCFunction)AEDesc_AEGetParamPtr, 1,
"(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)"},
PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)")},
{"AEGetParamDesc", (PyCFunction)AEDesc_AEGetParamDesc, 1,
"(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)"},
PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)")},
{"AESizeOfParam", (PyCFunction)AEDesc_AESizeOfParam, 1,
"(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)"},
PyDoc_STR("(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)")},
{"AEDeleteParam", (PyCFunction)AEDesc_AEDeleteParam, 1,
"(AEKeyword theAEKeyword) -> None"},
PyDoc_STR("(AEKeyword theAEKeyword) -> None")},
{"AEGetAttributePtr", (PyCFunction)AEDesc_AEGetAttributePtr, 1,
"(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)"},
PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType, Buffer dataPtr) -> (DescType typeCode, Buffer dataPtr)")},
{"AEGetAttributeDesc", (PyCFunction)AEDesc_AEGetAttributeDesc, 1,
"(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)"},
PyDoc_STR("(AEKeyword theAEKeyword, DescType desiredType) -> (AEDesc result)")},
{"AESizeOfAttribute", (PyCFunction)AEDesc_AESizeOfAttribute, 1,
"(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)"},
PyDoc_STR("(AEKeyword theAEKeyword) -> (DescType typeCode, Size dataSize)")},
{"AEPutAttributePtr", (PyCFunction)AEDesc_AEPutAttributePtr, 1,
"(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None"},
PyDoc_STR("(AEKeyword theAEKeyword, DescType typeCode, Buffer dataPtr) -> None")},
{"AEPutAttributeDesc", (PyCFunction)AEDesc_AEPutAttributeDesc, 1,
"(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None"},
PyDoc_STR("(AEKeyword theAEKeyword, AEDesc theAEDesc) -> None")},
#if TARGET_API_MAC_CARBON
{"AEGetDescDataSize", (PyCFunction)AEDesc_AEGetDescDataSize, 1,
"() -> (Size _rv)"},
PyDoc_STR("() -> (Size _rv)")},
#endif
{"AESend", (PyCFunction)AEDesc_AESend, 1,
"(AESendMode sendMode, AESendPriority sendPriority, long timeOutInTicks) -> (AppleEvent reply)"},
PyDoc_STR("(AESendMode sendMode, AESendPriority sendPriority, long timeOutInTicks) -> (AppleEvent reply)")},
{"AEResetTimer", (PyCFunction)AEDesc_AEResetTimer, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"AESuspendTheCurrentEvent", (PyCFunction)AEDesc_AESuspendTheCurrentEvent, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"AEResumeTheCurrentEvent", (PyCFunction)AEDesc_AEResumeTheCurrentEvent, 1,
"(AppleEvent reply, EventHandler dispatcher) -> None"},
PyDoc_STR("(AppleEvent reply, EventHandler dispatcher) -> None")},
{"AEGetTheCurrentEvent", (PyCFunction)AEDesc_AEGetTheCurrentEvent, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"AESetTheCurrentEvent", (PyCFunction)AEDesc_AESetTheCurrentEvent, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"AEResolve", (PyCFunction)AEDesc_AEResolve, 1,
"(short callbackFlags) -> (AEDesc theToken)"},
PyDoc_STR("(short callbackFlags) -> (AEDesc theToken)")},
{NULL, NULL, 0}
};
@ -1307,44 +1307,44 @@ static PyObject *AE_AECallObjectAccessor(PyObject *_self, PyObject *_args)
static PyMethodDef AE_methods[] = {
{"AECoercePtr", (PyCFunction)AE_AECoercePtr, 1,
"(DescType typeCode, Buffer dataPtr, DescType toType) -> (AEDesc result)"},
PyDoc_STR("(DescType typeCode, Buffer dataPtr, DescType toType) -> (AEDesc result)")},
{"AECreateDesc", (PyCFunction)AE_AECreateDesc, 1,
"(DescType typeCode, Buffer dataPtr) -> (AEDesc result)"},
PyDoc_STR("(DescType typeCode, Buffer dataPtr) -> (AEDesc result)")},
{"AECreateList", (PyCFunction)AE_AECreateList, 1,
"(Buffer factoringPtr, Boolean isRecord) -> (AEDescList resultList)"},
PyDoc_STR("(Buffer factoringPtr, Boolean isRecord) -> (AEDescList resultList)")},
{"AECreateAppleEvent", (PyCFunction)AE_AECreateAppleEvent, 1,
"(AEEventClass theAEEventClass, AEEventID theAEEventID, AEAddressDesc target, AEReturnID returnID, AETransactionID transactionID) -> (AppleEvent result)"},
PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID, AEAddressDesc target, AEReturnID returnID, AETransactionID transactionID) -> (AppleEvent result)")},
#if TARGET_API_MAC_CARBON
{"AEReplaceDescData", (PyCFunction)AE_AEReplaceDescData, 1,
"(DescType typeCode, Buffer dataPtr) -> (AEDesc theAEDesc)"},
PyDoc_STR("(DescType typeCode, Buffer dataPtr) -> (AEDesc theAEDesc)")},
#endif
{"AEProcessAppleEvent", (PyCFunction)AE_AEProcessAppleEvent, 1,
"(EventRecord theEventRecord) -> None"},
PyDoc_STR("(EventRecord theEventRecord) -> None")},
{"AEGetInteractionAllowed", (PyCFunction)AE_AEGetInteractionAllowed, 1,
"() -> (AEInteractAllowed level)"},
PyDoc_STR("() -> (AEInteractAllowed level)")},
{"AESetInteractionAllowed", (PyCFunction)AE_AESetInteractionAllowed, 1,
"(AEInteractAllowed level) -> None"},
PyDoc_STR("(AEInteractAllowed level) -> None")},
{"AEInteractWithUser", (PyCFunction)AE_AEInteractWithUser, 1,
"(long timeOutInTicks) -> None"},
PyDoc_STR("(long timeOutInTicks) -> None")},
{"AEInstallEventHandler", (PyCFunction)AE_AEInstallEventHandler, 1,
"(AEEventClass theAEEventClass, AEEventID theAEEventID, EventHandler handler) -> None"},
PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID, EventHandler handler) -> None")},
{"AERemoveEventHandler", (PyCFunction)AE_AERemoveEventHandler, 1,
"(AEEventClass theAEEventClass, AEEventID theAEEventID) -> None"},
PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID) -> None")},
{"AEGetEventHandler", (PyCFunction)AE_AEGetEventHandler, 1,
"(AEEventClass theAEEventClass, AEEventID theAEEventID) -> (EventHandler handler)"},
PyDoc_STR("(AEEventClass theAEEventClass, AEEventID theAEEventID) -> (EventHandler handler)")},
{"AEInstallSpecialHandler", (PyCFunction)AE_AEInstallSpecialHandler, 1,
"(AEKeyword functionClass) -> None"},
PyDoc_STR("(AEKeyword functionClass) -> None")},
{"AERemoveSpecialHandler", (PyCFunction)AE_AERemoveSpecialHandler, 1,
"(AEKeyword functionClass) -> None"},
PyDoc_STR("(AEKeyword functionClass) -> None")},
{"AEManagerInfo", (PyCFunction)AE_AEManagerInfo, 1,
"(AEKeyword keyWord) -> (long result)"},
PyDoc_STR("(AEKeyword keyWord) -> (long result)")},
{"AEObjectInit", (PyCFunction)AE_AEObjectInit, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"AEDisposeToken", (PyCFunction)AE_AEDisposeToken, 1,
"() -> (AEDesc theToken)"},
PyDoc_STR("() -> (AEDesc theToken)")},
{"AECallObjectAccessor", (PyCFunction)AE_AECallObjectAccessor, 1,
"(DescType desiredClass, AEDesc containerToken, DescType containerClass, DescType keyForm, AEDesc keyData) -> (AEDesc token)"},
PyDoc_STR("(DescType desiredClass, AEDesc containerToken, DescType containerClass, DescType keyForm, AEDesc keyData) -> (AEDesc token)")},
{NULL, NULL, 0}
};

134
Mac/Modules/app/_Appmodule.c
View File

@ -107,9 +107,9 @@ static PyObject *ThemeDrawingStateObj_DisposeThemeDrawingState(ThemeDrawingState
static PyMethodDef ThemeDrawingStateObj_methods[] = {
{"SetThemeDrawingState", (PyCFunction)ThemeDrawingStateObj_SetThemeDrawingState, 1,
"(Boolean inDisposeNow) -> (OSStatus _rv)"},
PyDoc_STR("(Boolean inDisposeNow) -> (OSStatus _rv)")},
{"DisposeThemeDrawingState", (PyCFunction)ThemeDrawingStateObj_DisposeThemeDrawingState, 1,
"() -> (OSStatus _rv)"},
PyDoc_STR("() -> (OSStatus _rv)")},
{NULL, NULL, 0}
};
@ -1646,149 +1646,149 @@ static PyObject *App_GetThemeMetric(PyObject *_self, PyObject *_args)
static PyMethodDef App_methods[] = {
{"RegisterAppearanceClient", (PyCFunction)App_RegisterAppearanceClient, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"UnregisterAppearanceClient", (PyCFunction)App_UnregisterAppearanceClient, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"SetThemePen", (PyCFunction)App_SetThemePen, 1,
"(ThemeBrush inBrush, SInt16 inDepth, Boolean inIsColorDevice) -> None"},
PyDoc_STR("(ThemeBrush inBrush, SInt16 inDepth, Boolean inIsColorDevice) -> None")},
{"SetThemeBackground", (PyCFunction)App_SetThemeBackground, 1,
"(ThemeBrush inBrush, SInt16 inDepth, Boolean inIsColorDevice) -> None"},
PyDoc_STR("(ThemeBrush inBrush, SInt16 inDepth, Boolean inIsColorDevice) -> None")},
{"SetThemeTextColor", (PyCFunction)App_SetThemeTextColor, 1,
"(ThemeTextColor inColor, SInt16 inDepth, Boolean inIsColorDevice) -> None"},
PyDoc_STR("(ThemeTextColor inColor, SInt16 inDepth, Boolean inIsColorDevice) -> None")},
{"SetThemeWindowBackground", (PyCFunction)App_SetThemeWindowBackground, 1,
"(WindowPtr inWindow, ThemeBrush inBrush, Boolean inUpdate) -> None"},
PyDoc_STR("(WindowPtr inWindow, ThemeBrush inBrush, Boolean inUpdate) -> None")},
{"DrawThemeWindowHeader", (PyCFunction)App_DrawThemeWindowHeader, 1,
"(Rect inRect, ThemeDrawState inState) -> None"},
PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
{"DrawThemeWindowListViewHeader", (PyCFunction)App_DrawThemeWindowListViewHeader, 1,
"(Rect inRect, ThemeDrawState inState) -> None"},
PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
{"DrawThemePlacard", (PyCFunction)App_DrawThemePlacard, 1,
"(Rect inRect, ThemeDrawState inState) -> None"},
PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
{"DrawThemeEditTextFrame", (PyCFunction)App_DrawThemeEditTextFrame, 1,
"(Rect inRect, ThemeDrawState inState) -> None"},
PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
{"DrawThemeListBoxFrame", (PyCFunction)App_DrawThemeListBoxFrame, 1,
"(Rect inRect, ThemeDrawState inState) -> None"},
PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
{"DrawThemeFocusRect", (PyCFunction)App_DrawThemeFocusRect, 1,
"(Rect inRect, Boolean inHasFocus) -> None"},
PyDoc_STR("(Rect inRect, Boolean inHasFocus) -> None")},
{"DrawThemePrimaryGroup", (PyCFunction)App_DrawThemePrimaryGroup, 1,
"(Rect inRect, ThemeDrawState inState) -> None"},
PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
{"DrawThemeSecondaryGroup", (PyCFunction)App_DrawThemeSecondaryGroup, 1,
"(Rect inRect, ThemeDrawState inState) -> None"},
PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
{"DrawThemeSeparator", (PyCFunction)App_DrawThemeSeparator, 1,
"(Rect inRect, ThemeDrawState inState) -> None"},
PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
{"DrawThemeModelessDialogFrame", (PyCFunction)App_DrawThemeModelessDialogFrame, 1,
"(Rect inRect, ThemeDrawState inState) -> None"},
PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
{"DrawThemeGenericWell", (PyCFunction)App_DrawThemeGenericWell, 1,
"(Rect inRect, ThemeDrawState inState, Boolean inFillCenter) -> None"},
PyDoc_STR("(Rect inRect, ThemeDrawState inState, Boolean inFillCenter) -> None")},
{"DrawThemeFocusRegion", (PyCFunction)App_DrawThemeFocusRegion, 1,
"(Boolean inHasFocus) -> None"},
PyDoc_STR("(Boolean inHasFocus) -> None")},
{"IsThemeInColor", (PyCFunction)App_IsThemeInColor, 1,
"(SInt16 inDepth, Boolean inIsColorDevice) -> (Boolean _rv)"},
PyDoc_STR("(SInt16 inDepth, Boolean inIsColorDevice) -> (Boolean _rv)")},
{"GetThemeAccentColors", (PyCFunction)App_GetThemeAccentColors, 1,
"() -> (CTabHandle outColors)"},
PyDoc_STR("() -> (CTabHandle outColors)")},
{"DrawThemeMenuBarBackground", (PyCFunction)App_DrawThemeMenuBarBackground, 1,
"(Rect inBounds, ThemeMenuBarState inState, UInt32 inAttributes) -> None"},
PyDoc_STR("(Rect inBounds, ThemeMenuBarState inState, UInt32 inAttributes) -> None")},
{"GetThemeMenuBarHeight", (PyCFunction)App_GetThemeMenuBarHeight, 1,
"() -> (SInt16 outHeight)"},
PyDoc_STR("() -> (SInt16 outHeight)")},
{"DrawThemeMenuBackground", (PyCFunction)App_DrawThemeMenuBackground, 1,
"(Rect inMenuRect, ThemeMenuType inMenuType) -> None"},
PyDoc_STR("(Rect inMenuRect, ThemeMenuType inMenuType) -> None")},
{"GetThemeMenuBackgroundRegion", (PyCFunction)App_GetThemeMenuBackgroundRegion, 1,
"(Rect inMenuRect, ThemeMenuType menuType) -> None"},
PyDoc_STR("(Rect inMenuRect, ThemeMenuType menuType) -> None")},
{"DrawThemeMenuSeparator", (PyCFunction)App_DrawThemeMenuSeparator, 1,
"(Rect inItemRect) -> None"},
PyDoc_STR("(Rect inItemRect) -> None")},
{"GetThemeMenuSeparatorHeight", (PyCFunction)App_GetThemeMenuSeparatorHeight, 1,
"() -> (SInt16 outHeight)"},
PyDoc_STR("() -> (SInt16 outHeight)")},
{"GetThemeMenuItemExtra", (PyCFunction)App_GetThemeMenuItemExtra, 1,
"(ThemeMenuItemType inItemType) -> (SInt16 outHeight, SInt16 outWidth)"},
PyDoc_STR("(ThemeMenuItemType inItemType) -> (SInt16 outHeight, SInt16 outWidth)")},
{"GetThemeMenuTitleExtra", (PyCFunction)App_GetThemeMenuTitleExtra, 1,
"(Boolean inIsSquished) -> (SInt16 outWidth)"},
PyDoc_STR("(Boolean inIsSquished) -> (SInt16 outWidth)")},
{"DrawThemeTabPane", (PyCFunction)App_DrawThemeTabPane, 1,
"(Rect inRect, ThemeDrawState inState) -> None"},
PyDoc_STR("(Rect inRect, ThemeDrawState inState) -> None")},
{"GetThemeTabRegion", (PyCFunction)App_GetThemeTabRegion, 1,
"(Rect inRect, ThemeTabStyle inStyle, ThemeTabDirection inDirection) -> None"},
PyDoc_STR("(Rect inRect, ThemeTabStyle inStyle, ThemeTabDirection inDirection) -> None")},
{"SetThemeCursor", (PyCFunction)App_SetThemeCursor, 1,
"(ThemeCursor inCursor) -> None"},
PyDoc_STR("(ThemeCursor inCursor) -> None")},
{"SetAnimatedThemeCursor", (PyCFunction)App_SetAnimatedThemeCursor, 1,
"(ThemeCursor inCursor, UInt32 inAnimationStep) -> None"},
PyDoc_STR("(ThemeCursor inCursor, UInt32 inAnimationStep) -> None")},
{"GetThemeScrollBarThumbStyle", (PyCFunction)App_GetThemeScrollBarThumbStyle, 1,
"() -> (ThemeScrollBarThumbStyle outStyle)"},
PyDoc_STR("() -> (ThemeScrollBarThumbStyle outStyle)")},
{"GetThemeScrollBarArrowStyle", (PyCFunction)App_GetThemeScrollBarArrowStyle, 1,
"() -> (ThemeScrollBarArrowStyle outStyle)"},
PyDoc_STR("() -> (ThemeScrollBarArrowStyle outStyle)")},
{"GetThemeCheckBoxStyle", (PyCFunction)App_GetThemeCheckBoxStyle, 1,
"() -> (ThemeCheckBoxStyle outStyle)"},
PyDoc_STR("() -> (ThemeCheckBoxStyle outStyle)")},
{"UseThemeFont", (PyCFunction)App_UseThemeFont, 1,
"(ThemeFontID inFontID, ScriptCode inScript) -> None"},
PyDoc_STR("(ThemeFontID inFontID, ScriptCode inScript) -> None")},
#if TARGET_API_MAC_CARBON
{"DrawThemeTextBox", (PyCFunction)App_DrawThemeTextBox, 1,
"(CFStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, Boolean inWrapToWidth, Rect inBoundingBox, SInt16 inJust) -> None"},
PyDoc_STR("(CFStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, Boolean inWrapToWidth, Rect inBoundingBox, SInt16 inJust) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"TruncateThemeText", (PyCFunction)App_TruncateThemeText, 1,
"(CFMutableStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, SInt16 inPixelWidthLimit, TruncCode inTruncWhere) -> (Boolean outTruncated)"},
PyDoc_STR("(CFMutableStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, SInt16 inPixelWidthLimit, TruncCode inTruncWhere) -> (Boolean outTruncated)")},
#endif
#if TARGET_API_MAC_CARBON
{"GetThemeTextDimensions", (PyCFunction)App_GetThemeTextDimensions, 1,
"(CFStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, Boolean inWrapToWidth, Point ioBounds) -> (Point ioBounds, SInt16 outBaseline)"},
PyDoc_STR("(CFStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, Boolean inWrapToWidth, Point ioBounds) -> (Point ioBounds, SInt16 outBaseline)")},
#endif
#if TARGET_API_MAC_CARBON
{"GetThemeTextShadowOutset", (PyCFunction)App_GetThemeTextShadowOutset, 1,
"(ThemeFontID inFontID, ThemeDrawState inState) -> (Rect outOutset)"},
PyDoc_STR("(ThemeFontID inFontID, ThemeDrawState inState) -> (Rect outOutset)")},
#endif
{"DrawThemeScrollBarArrows", (PyCFunction)App_DrawThemeScrollBarArrows, 1,
"(Rect bounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz) -> (Rect trackBounds)"},
PyDoc_STR("(Rect bounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz) -> (Rect trackBounds)")},
{"GetThemeScrollBarTrackRect", (PyCFunction)App_GetThemeScrollBarTrackRect, 1,
"(Rect bounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz) -> (Rect trackBounds)"},
PyDoc_STR("(Rect bounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz) -> (Rect trackBounds)")},
{"HitTestThemeScrollBarArrows", (PyCFunction)App_HitTestThemeScrollBarArrows, 1,
"(Rect scrollBarBounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz, Point ptHit) -> (Boolean _rv, Rect trackBounds, ControlPartCode partcode)"},
PyDoc_STR("(Rect scrollBarBounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz, Point ptHit) -> (Boolean _rv, Rect trackBounds, ControlPartCode partcode)")},
{"DrawThemeScrollBarDelimiters", (PyCFunction)App_DrawThemeScrollBarDelimiters, 1,
"(ThemeWindowType flavor, Rect inContRect, ThemeDrawState state, ThemeWindowAttributes attributes) -> None"},
PyDoc_STR("(ThemeWindowType flavor, Rect inContRect, ThemeDrawState state, ThemeWindowAttributes attributes) -> None")},
{"DrawThemeButton", (PyCFunction)App_DrawThemeButton, 1,
"(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inNewInfo, ThemeButtonDrawInfo inPrevInfo, UInt32 inUserData) -> None"},
PyDoc_STR("(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inNewInfo, ThemeButtonDrawInfo inPrevInfo, UInt32 inUserData) -> None")},
{"GetThemeButtonRegion", (PyCFunction)App_GetThemeButtonRegion, 1,
"(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inNewInfo) -> None"},
PyDoc_STR("(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inNewInfo) -> None")},
{"GetThemeButtonContentBounds", (PyCFunction)App_GetThemeButtonContentBounds, 1,
"(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inDrawInfo) -> (Rect outBounds)"},
PyDoc_STR("(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inDrawInfo) -> (Rect outBounds)")},
{"GetThemeButtonBackgroundBounds", (PyCFunction)App_GetThemeButtonBackgroundBounds, 1,
"(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inDrawInfo) -> (Rect outBounds)"},
PyDoc_STR("(Rect inBounds, UInt16 inKind, ThemeButtonDrawInfo inDrawInfo) -> (Rect outBounds)")},
{"PlayThemeSound", (PyCFunction)App_PlayThemeSound, 1,
"(ThemeSoundKind kind) -> None"},
PyDoc_STR("(ThemeSoundKind kind) -> None")},
{"BeginThemeDragSound", (PyCFunction)App_BeginThemeDragSound, 1,
"(ThemeDragSoundKind kind) -> None"},
PyDoc_STR("(ThemeDragSoundKind kind) -> None")},
{"EndThemeDragSound", (PyCFunction)App_EndThemeDragSound, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"DrawThemeTickMark", (PyCFunction)App_DrawThemeTickMark, 1,
"(Rect bounds, ThemeDrawState state) -> None"},
PyDoc_STR("(Rect bounds, ThemeDrawState state) -> None")},
{"DrawThemeChasingArrows", (PyCFunction)App_DrawThemeChasingArrows, 1,
"(Rect bounds, UInt32 index, ThemeDrawState state, UInt32 eraseData) -> None"},
PyDoc_STR("(Rect bounds, UInt32 index, ThemeDrawState state, UInt32 eraseData) -> None")},
{"DrawThemePopupArrow", (PyCFunction)App_DrawThemePopupArrow, 1,
"(Rect bounds, ThemeArrowOrientation orientation, ThemePopupArrowSize size, ThemeDrawState state, UInt32 eraseData) -> None"},
PyDoc_STR("(Rect bounds, ThemeArrowOrientation orientation, ThemePopupArrowSize size, ThemeDrawState state, UInt32 eraseData) -> None")},
{"DrawThemeStandaloneGrowBox", (PyCFunction)App_DrawThemeStandaloneGrowBox, 1,
"(Point origin, ThemeGrowDirection growDirection, Boolean isSmall, ThemeDrawState state) -> None"},
PyDoc_STR("(Point origin, ThemeGrowDirection growDirection, Boolean isSmall, ThemeDrawState state) -> None")},
{"DrawThemeStandaloneNoGrowBox", (PyCFunction)App_DrawThemeStandaloneNoGrowBox, 1,
"(Point origin, ThemeGrowDirection growDirection, Boolean isSmall, ThemeDrawState state) -> None"},
PyDoc_STR("(Point origin, ThemeGrowDirection growDirection, Boolean isSmall, ThemeDrawState state) -> None")},
{"GetThemeStandaloneGrowBoxBounds", (PyCFunction)App_GetThemeStandaloneGrowBoxBounds, 1,
"(Point origin, ThemeGrowDirection growDirection, Boolean isSmall) -> (Rect bounds)"},
PyDoc_STR("(Point origin, ThemeGrowDirection growDirection, Boolean isSmall) -> (Rect bounds)")},
{"NormalizeThemeDrawingState", (PyCFunction)App_NormalizeThemeDrawingState, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"GetThemeDrawingState", (PyCFunction)App_GetThemeDrawingState, 1,
"() -> (ThemeDrawingState outState)"},
PyDoc_STR("() -> (ThemeDrawingState outState)")},
{"ApplyThemeBackground", (PyCFunction)App_ApplyThemeBackground, 1,
"(ThemeBackgroundKind inKind, Rect bounds, ThemeDrawState inState, SInt16 inDepth, Boolean inColorDev) -> None"},
PyDoc_STR("(ThemeBackgroundKind inKind, Rect bounds, ThemeDrawState inState, SInt16 inDepth, Boolean inColorDev) -> None")},
{"SetThemeTextColorForWindow", (PyCFunction)App_SetThemeTextColorForWindow, 1,
"(WindowPtr window, Boolean isActive, SInt16 depth, Boolean isColorDev) -> None"},
PyDoc_STR("(WindowPtr window, Boolean isActive, SInt16 depth, Boolean isColorDev) -> None")},
{"IsValidAppearanceFileType", (PyCFunction)App_IsValidAppearanceFileType, 1,
"(OSType fileType) -> (Boolean _rv)"},
PyDoc_STR("(OSType fileType) -> (Boolean _rv)")},
{"GetThemeBrushAsColor", (PyCFunction)App_GetThemeBrushAsColor, 1,
"(ThemeBrush inBrush, SInt16 inDepth, Boolean inColorDev) -> (RGBColor outColor)"},
PyDoc_STR("(ThemeBrush inBrush, SInt16 inDepth, Boolean inColorDev) -> (RGBColor outColor)")},
{"GetThemeTextColor", (PyCFunction)App_GetThemeTextColor, 1,
"(ThemeTextColor inColor, SInt16 inDepth, Boolean inColorDev) -> (RGBColor outColor)"},
PyDoc_STR("(ThemeTextColor inColor, SInt16 inDepth, Boolean inColorDev) -> (RGBColor outColor)")},
#if TARGET_API_MAC_CARBON
{"GetThemeMetric", (PyCFunction)App_GetThemeMetric, 1,
"(ThemeMetric inMetric) -> (SInt32 outMetric)"},
PyDoc_STR("(ThemeMetric inMetric) -> (SInt32 outMetric)")},
#endif
{NULL, NULL, 0}
};

118
Mac/Modules/carbonevt/_CarbonEvtmodule.c
View File

@ -380,31 +380,31 @@ static PyObject *EventRef_GetEventParameter(EventRefObject *_self, PyObject *_ar
static PyMethodDef EventRef_methods[] = {
{"RetainEvent", (PyCFunction)EventRef_RetainEvent, 1,
"() -> (EventRef _rv)"},
PyDoc_STR("() -> (EventRef _rv)")},
{"GetEventRetainCount", (PyCFunction)EventRef_GetEventRetainCount, 1,
"() -> (UInt32 _rv)"},
PyDoc_STR("() -> (UInt32 _rv)")},
{"ReleaseEvent", (PyCFunction)EventRef_ReleaseEvent, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"SetEventParameter", (PyCFunction)EventRef_SetEventParameter, 1,
"(OSType inName, OSType inType, Buffer inDataPtr) -> None"},
PyDoc_STR("(OSType inName, OSType inType, Buffer inDataPtr) -> None")},
{"GetEventClass", (PyCFunction)EventRef_GetEventClass, 1,
"() -> (UInt32 _rv)"},
PyDoc_STR("() -> (UInt32 _rv)")},
{"GetEventKind", (PyCFunction)EventRef_GetEventKind, 1,
"() -> (UInt32 _rv)"},
PyDoc_STR("() -> (UInt32 _rv)")},
{"GetEventTime", (PyCFunction)EventRef_GetEventTime, 1,
"() -> (double _rv)"},
PyDoc_STR("() -> (double _rv)")},
{"SetEventTime", (PyCFunction)EventRef_SetEventTime, 1,
"(double inTime) -> None"},
PyDoc_STR("(double inTime) -> None")},
{"IsUserCancelEventRef", (PyCFunction)EventRef_IsUserCancelEventRef, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
{"ConvertEventRefToEventRecord", (PyCFunction)EventRef_ConvertEventRefToEventRecord, 1,
"() -> (Boolean _rv, EventRecord outEvent)"},
PyDoc_STR("() -> (Boolean _rv, EventRecord outEvent)")},
{"IsEventInMask", (PyCFunction)EventRef_IsEventInMask, 1,
"(UInt16 inMask) -> (Boolean _rv)"},
PyDoc_STR("(UInt16 inMask) -> (Boolean _rv)")},
{"SendEventToEventTarget", (PyCFunction)EventRef_SendEventToEventTarget, 1,
"(EventTargetRef inTarget) -> None"},
PyDoc_STR("(EventTargetRef inTarget) -> None")},
{"GetEventParameter", (PyCFunction)EventRef_GetEventParameter, 1,
"(EventParamName eventName, EventParamType eventType) -> (String eventParamData)"},
PyDoc_STR("(EventParamName eventName, EventParamType eventType) -> (String eventParamData)")},
{NULL, NULL, 0}
};
@ -577,17 +577,17 @@ static PyObject *EventQueueRef_IsEventInQueue(EventQueueRefObject *_self, PyObje
static PyMethodDef EventQueueRef_methods[] = {
{"PostEventToQueue", (PyCFunction)EventQueueRef_PostEventToQueue, 1,
"(EventRef inEvent, SInt16 inPriority) -> None"},
PyDoc_STR("(EventRef inEvent, SInt16 inPriority) -> None")},
{"FlushEventsMatchingListFromQueue", (PyCFunction)EventQueueRef_FlushEventsMatchingListFromQueue, 1,
"(UInt32 inNumTypes, EventTypeSpec inList) -> None"},
PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
{"FlushEventQueue", (PyCFunction)EventQueueRef_FlushEventQueue, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"GetNumEventsInQueue", (PyCFunction)EventQueueRef_GetNumEventsInQueue, 1,
"() -> (UInt32 _rv)"},
PyDoc_STR("() -> (UInt32 _rv)")},
{"RemoveEventFromQueue", (PyCFunction)EventQueueRef_RemoveEventFromQueue, 1,
"(EventRef inEvent) -> None"},
PyDoc_STR("(EventRef inEvent) -> None")},
{"IsEventInQueue", (PyCFunction)EventQueueRef_IsEventInQueue, 1,
"(EventRef inEvent) -> (Boolean _rv)"},
PyDoc_STR("(EventRef inEvent) -> (Boolean _rv)")},
{NULL, NULL, 0}
};
@ -679,7 +679,7 @@ static PyObject *EventLoopRef_QuitEventLoop(EventLoopRefObject *_self, PyObject
static PyMethodDef EventLoopRef_methods[] = {
{"QuitEventLoop", (PyCFunction)EventLoopRef_QuitEventLoop, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{NULL, NULL, 0}
};
@ -787,9 +787,9 @@ static PyObject *EventLoopTimerRef_SetEventLoopTimerNextFireTime(EventLoopTimerR
static PyMethodDef EventLoopTimerRef_methods[] = {
{"RemoveEventLoopTimer", (PyCFunction)EventLoopTimerRef_RemoveEventLoopTimer, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"SetEventLoopTimerNextFireTime", (PyCFunction)EventLoopTimerRef_SetEventLoopTimerNextFireTime, 1,
"(double inNextFire) -> None"},
PyDoc_STR("(double inNextFire) -> None")},
{NULL, NULL, 0}
};
@ -940,11 +940,11 @@ static PyObject *EventHandlerRef_RemoveEventHandler(EventHandlerRefObject *_self
static PyMethodDef EventHandlerRef_methods[] = {
{"AddEventTypesToHandler", (PyCFunction)EventHandlerRef_AddEventTypesToHandler, 1,
"(UInt32 inNumTypes, EventTypeSpec inList) -> None"},
PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
{"RemoveEventTypesFromHandler", (PyCFunction)EventHandlerRef_RemoveEventTypesFromHandler, 1,
"(UInt32 inNumTypes, EventTypeSpec inList) -> None"},
PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList) -> None")},
{"RemoveEventHandler", (PyCFunction)EventHandlerRef_RemoveEventHandler, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{NULL, NULL, 0}
};
@ -1039,7 +1039,7 @@ static PyObject *EventHandlerCallRef_CallNextEventHandler(EventHandlerCallRefObj
static PyMethodDef EventHandlerCallRef_methods[] = {
{"CallNextEventHandler", (PyCFunction)EventHandlerCallRef_CallNextEventHandler, 1,
"(EventRef inEvent) -> None"},
PyDoc_STR("(EventRef inEvent) -> None")},
{NULL, NULL, 0}
};
@ -1154,9 +1154,9 @@ static PyObject *EventTargetRef_InstallEventHandler(EventTargetRefObject *_self,
static PyMethodDef EventTargetRef_methods[] = {
{"InstallStandardEventHandler", (PyCFunction)EventTargetRef_InstallStandardEventHandler, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"InstallEventHandler", (PyCFunction)EventTargetRef_InstallEventHandler, 1,
"(EventTypeSpec inSpec, Method callback) -> (EventHandlerRef outRef)"},
PyDoc_STR("(EventTypeSpec inSpec, Method callback) -> (EventHandlerRef outRef)")},
{NULL, NULL, 0}
};
@ -1248,7 +1248,7 @@ static PyObject *EventHotKeyRef_UnregisterEventHotKey(EventHotKeyRefObject *_sel
static PyMethodDef EventHotKeyRef_methods[] = {
{"UnregisterEventHotKey", (PyCFunction)EventHotKeyRef_UnregisterEventHotKey, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{NULL, NULL, 0}
};
@ -1778,65 +1778,65 @@ static PyObject *CarbonEvents_RunApplicationEventLoop(PyObject *_self, PyObject
static PyMethodDef CarbonEvents_methods[] = {
{"GetCurrentEventLoop", (PyCFunction)CarbonEvents_GetCurrentEventLoop, 1,
"() -> (EventLoopRef _rv)"},
PyDoc_STR("() -> (EventLoopRef _rv)")},
{"GetMainEventLoop", (PyCFunction)CarbonEvents_GetMainEventLoop, 1,
"() -> (EventLoopRef _rv)"},
PyDoc_STR("() -> (EventLoopRef _rv)")},
{"RunCurrentEventLoop", (PyCFunction)CarbonEvents_RunCurrentEventLoop, 1,
"(double inTimeout) -> None"},
PyDoc_STR("(double inTimeout) -> None")},
{"ReceiveNextEvent", (PyCFunction)CarbonEvents_ReceiveNextEvent, 1,
"(UInt32 inNumTypes, EventTypeSpec inList, double inTimeout, Boolean inPullEvent) -> (EventRef outEvent)"},
PyDoc_STR("(UInt32 inNumTypes, EventTypeSpec inList, double inTimeout, Boolean inPullEvent) -> (EventRef outEvent)")},
{"GetCurrentEventQueue", (PyCFunction)CarbonEvents_GetCurrentEventQueue, 1,
"() -> (EventQueueRef _rv)"},
PyDoc_STR("() -> (EventQueueRef _rv)")},
{"GetMainEventQueue", (PyCFunction)CarbonEvents_GetMainEventQueue, 1,
"() -> (EventQueueRef _rv)"},
PyDoc_STR("() -> (EventQueueRef _rv)")},
{"GetCurrentEventTime", (PyCFunction)CarbonEvents_GetCurrentEventTime, 1,
"() -> (double _rv)"},
PyDoc_STR("() -> (double _rv)")},
{"TrackMouseLocation", (PyCFunction)CarbonEvents_TrackMouseLocation, 1,
"(GrafPtr inPort) -> (Point outPt, UInt16 outResult)"},
PyDoc_STR("(GrafPtr inPort) -> (Point outPt, UInt16 outResult)")},
{"TrackMouseLocationWithOptions", (PyCFunction)CarbonEvents_TrackMouseLocationWithOptions, 1,
"(GrafPtr inPort, OptionBits inOptions, double inTimeout) -> (Point outPt, UInt32 outModifiers, UInt16 outResult)"},
PyDoc_STR("(GrafPtr inPort, OptionBits inOptions, double inTimeout) -> (Point outPt, UInt32 outModifiers, UInt16 outResult)")},
{"TrackMouseRegion", (PyCFunction)CarbonEvents_TrackMouseRegion, 1,
"(GrafPtr inPort, RgnHandle inRegion, Boolean ioWasInRgn) -> (Boolean ioWasInRgn, UInt16 outResult)"},
PyDoc_STR("(GrafPtr inPort, RgnHandle inRegion, Boolean ioWasInRgn) -> (Boolean ioWasInRgn, UInt16 outResult)")},
{"GetLastUserEventTime", (PyCFunction)CarbonEvents_GetLastUserEventTime, 1,
"() -> (double _rv)"},
PyDoc_STR("() -> (double _rv)")},
{"GetWindowEventTarget", (PyCFunction)CarbonEvents_GetWindowEventTarget, 1,
"(WindowPtr inWindow) -> (EventTargetRef _rv)"},
PyDoc_STR("(WindowPtr inWindow) -> (EventTargetRef _rv)")},
{"GetControlEventTarget", (PyCFunction)CarbonEvents_GetControlEventTarget, 1,
"(ControlHandle inControl) -> (EventTargetRef _rv)"},
PyDoc_STR("(ControlHandle inControl) -> (EventTargetRef _rv)")},
{"GetMenuEventTarget", (PyCFunction)CarbonEvents_GetMenuEventTarget, 1,
"(MenuHandle inMenu) -> (EventTargetRef _rv)"},
PyDoc_STR("(MenuHandle inMenu) -> (EventTargetRef _rv)")},
{"GetApplicationEventTarget", (PyCFunction)CarbonEvents_GetApplicationEventTarget, 1,
"() -> (EventTargetRef _rv)"},
PyDoc_STR("() -> (EventTargetRef _rv)")},
{"GetUserFocusEventTarget", (PyCFunction)CarbonEvents_GetUserFocusEventTarget, 1,
"() -> (EventTargetRef _rv)"},
PyDoc_STR("() -> (EventTargetRef _rv)")},
{"GetEventDispatcherTarget", (PyCFunction)CarbonEvents_GetEventDispatcherTarget, 1,
"() -> (EventTargetRef _rv)"},
PyDoc_STR("() -> (EventTargetRef _rv)")},
{"QuitApplicationEventLoop", (PyCFunction)CarbonEvents_QuitApplicationEventLoop, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"RunAppModalLoopForWindow", (PyCFunction)CarbonEvents_RunAppModalLoopForWindow, 1,
"(WindowPtr inWindow) -> None"},
PyDoc_STR("(WindowPtr inWindow) -> None")},
{"QuitAppModalLoopForWindow", (PyCFunction)CarbonEvents_QuitAppModalLoopForWindow, 1,
"(WindowPtr inWindow) -> None"},
PyDoc_STR("(WindowPtr inWindow) -> None")},
{"BeginAppModalStateForWindow", (PyCFunction)CarbonEvents_BeginAppModalStateForWindow, 1,
"(WindowPtr inWindow) -> None"},
PyDoc_STR("(WindowPtr inWindow) -> None")},
{"EndAppModalStateForWindow", (PyCFunction)CarbonEvents_EndAppModalStateForWindow, 1,
"(WindowPtr inWindow) -> None"},
PyDoc_STR("(WindowPtr inWindow) -> None")},
{"SetUserFocusWindow", (PyCFunction)CarbonEvents_SetUserFocusWindow, 1,
"(WindowPtr inWindow) -> None"},
PyDoc_STR("(WindowPtr inWindow) -> None")},
{"GetUserFocusWindow", (PyCFunction)CarbonEvents_GetUserFocusWindow, 1,
"() -> (WindowPtr _rv)"},
PyDoc_STR("() -> (WindowPtr _rv)")},
{"SetWindowDefaultButton", (PyCFunction)CarbonEvents_SetWindowDefaultButton, 1,
"(WindowPtr inWindow, ControlHandle inControl) -> None"},
PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl) -> None")},
{"SetWindowCancelButton", (PyCFunction)CarbonEvents_SetWindowCancelButton, 1,
"(WindowPtr inWindow, ControlHandle inControl) -> None"},
PyDoc_STR("(WindowPtr inWindow, ControlHandle inControl) -> None")},
{"GetWindowDefaultButton", (PyCFunction)CarbonEvents_GetWindowDefaultButton, 1,
"(WindowPtr inWindow) -> (ControlHandle outControl)"},
PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")},
{"GetWindowCancelButton", (PyCFunction)CarbonEvents_GetWindowCancelButton, 1,
"(WindowPtr inWindow) -> (ControlHandle outControl)"},
PyDoc_STR("(WindowPtr inWindow) -> (ControlHandle outControl)")},
{"RegisterEventHotKey", (PyCFunction)CarbonEvents_RegisterEventHotKey, 1,
"(UInt32 inHotKeyCode, UInt32 inHotKeyModifiers, EventHotKeyID inHotKeyID, EventTargetRef inTarget, OptionBits inOptions) -> (EventHotKeyRef outRef)"},
PyDoc_STR("(UInt32 inHotKeyCode, UInt32 inHotKeyModifiers, EventHotKeyID inHotKeyID, EventTargetRef inTarget, OptionBits inOptions) -> (EventHotKeyRef outRef)")},
{"RunApplicationEventLoop", (PyCFunction)CarbonEvents_RunApplicationEventLoop, 1,
"() -> ()"},
PyDoc_STR("() -> ()")},
{NULL, NULL, 0}
};

304
Mac/Modules/cf/_CFmodule.c
View File

@ -360,29 +360,29 @@ static PyObject *CFTypeRefObj_toPython(CFTypeRefObject *_self, PyObject *_args)
static PyMethodDef CFTypeRefObj_methods[] = {
{"CFGetTypeID", (PyCFunction)CFTypeRefObj_CFGetTypeID, 1,
"() -> (CFTypeID _rv)"},
PyDoc_STR("() -> (CFTypeID _rv)")},
{"CFRetain", (PyCFunction)CFTypeRefObj_CFRetain, 1,
"() -> (CFTypeRef _rv)"},
PyDoc_STR("() -> (CFTypeRef _rv)")},
{"CFRelease", (PyCFunction)CFTypeRefObj_CFRelease, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CFGetRetainCount", (PyCFunction)CFTypeRefObj_CFGetRetainCount, 1,
"() -> (CFIndex _rv)"},
PyDoc_STR("() -> (CFIndex _rv)")},
{"CFEqual", (PyCFunction)CFTypeRefObj_CFEqual, 1,
"(CFTypeRef cf2) -> (Boolean _rv)"},
PyDoc_STR("(CFTypeRef cf2) -> (Boolean _rv)")},
{"CFHash", (PyCFunction)CFTypeRefObj_CFHash, 1,
"() -> (CFHashCode _rv)"},
PyDoc_STR("() -> (CFHashCode _rv)")},
{"CFCopyDescription", (PyCFunction)CFTypeRefObj_CFCopyDescription, 1,
"() -> (CFStringRef _rv)"},
PyDoc_STR("() -> (CFStringRef _rv)")},
{"CFPropertyListCreateXMLData", (PyCFunction)CFTypeRefObj_CFPropertyListCreateXMLData, 1,
"() -> (CFDataRef _rv)"},
PyDoc_STR("() -> (CFDataRef _rv)")},
{"CFPropertyListCreateDeepCopy", (PyCFunction)CFTypeRefObj_CFPropertyListCreateDeepCopy, 1,
"(CFOptionFlags mutabilityOption) -> (CFTypeRef _rv)"},
PyDoc_STR("(CFOptionFlags mutabilityOption) -> (CFTypeRef _rv)")},
{"CFShow", (PyCFunction)CFTypeRefObj_CFShow, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CFPropertyListCreateFromXMLData", (PyCFunction)CFTypeRefObj_CFPropertyListCreateFromXMLData, 1,
"(CFOptionFlags mutabilityOption) -> (CFTypeRefObj)"},
PyDoc_STR("(CFOptionFlags mutabilityOption) -> (CFTypeRefObj)")},
{"toPython", (PyCFunction)CFTypeRefObj_toPython, 1,
"() -> (python_object)"},
PyDoc_STR("() -> (python_object)")},
{NULL, NULL, 0}
};
@ -534,11 +534,11 @@ static PyObject *CFArrayRefObj_CFStringCreateByCombiningStrings(CFArrayRefObject
static PyMethodDef CFArrayRefObj_methods[] = {
{"CFArrayCreateCopy", (PyCFunction)CFArrayRefObj_CFArrayCreateCopy, 1,
"() -> (CFArrayRef _rv)"},
PyDoc_STR("() -> (CFArrayRef _rv)")},
{"CFArrayGetCount", (PyCFunction)CFArrayRefObj_CFArrayGetCount, 1,
"() -> (CFIndex _rv)"},
PyDoc_STR("() -> (CFIndex _rv)")},
{"CFStringCreateByCombiningStrings", (PyCFunction)CFArrayRefObj_CFStringCreateByCombiningStrings, 1,
"(CFStringRef separatorString) -> (CFStringRef _rv)"},
PyDoc_STR("(CFStringRef separatorString) -> (CFStringRef _rv)")},
{NULL, NULL, 0}
};
@ -717,13 +717,13 @@ static PyObject *CFMutableArrayRefObj_CFArrayAppendArray(CFMutableArrayRefObject
static PyMethodDef CFMutableArrayRefObj_methods[] = {
{"CFArrayRemoveValueAtIndex", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveValueAtIndex, 1,
"(CFIndex idx) -> None"},
PyDoc_STR("(CFIndex idx) -> None")},
{"CFArrayRemoveAllValues", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveAllValues, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CFArrayExchangeValuesAtIndices", (PyCFunction)CFMutableArrayRefObj_CFArrayExchangeValuesAtIndices, 1,
"(CFIndex idx1, CFIndex idx2) -> None"},
PyDoc_STR("(CFIndex idx1, CFIndex idx2) -> None")},
{"CFArrayAppendArray", (PyCFunction)CFMutableArrayRefObj_CFArrayAppendArray, 1,
"(CFArrayRef otherArray, CFRange otherRange) -> None"},
PyDoc_STR("(CFArrayRef otherArray, CFRange otherRange) -> None")},
{NULL, NULL, 0}
};
@ -859,9 +859,9 @@ static PyObject *CFDictionaryRefObj_CFDictionaryGetCount(CFDictionaryRefObject *
static PyMethodDef CFDictionaryRefObj_methods[] = {
{"CFDictionaryCreateCopy", (PyCFunction)CFDictionaryRefObj_CFDictionaryCreateCopy, 1,
"() -> (CFDictionaryRef _rv)"},
PyDoc_STR("() -> (CFDictionaryRef _rv)")},
{"CFDictionaryGetCount", (PyCFunction)CFDictionaryRefObj_CFDictionaryGetCount, 1,
"() -> (CFIndex _rv)"},
PyDoc_STR("() -> (CFIndex _rv)")},
{NULL, NULL, 0}
};
@ -983,7 +983,7 @@ static PyObject *CFMutableDictionaryRefObj_CFDictionaryRemoveAllValues(CFMutable
static PyMethodDef CFMutableDictionaryRefObj_methods[] = {
{"CFDictionaryRemoveAllValues", (PyCFunction)CFMutableDictionaryRefObj_CFDictionaryRemoveAllValues, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{NULL, NULL, 0}
};
@ -1153,13 +1153,13 @@ static PyObject *CFDataRefObj_CFDataGetData(CFDataRefObject *_self, PyObject *_a
static PyMethodDef CFDataRefObj_methods[] = {
{"CFDataCreateCopy", (PyCFunction)CFDataRefObj_CFDataCreateCopy, 1,
"() -> (CFDataRef _rv)"},
PyDoc_STR("() -> (CFDataRef _rv)")},
{"CFDataGetLength", (PyCFunction)CFDataRefObj_CFDataGetLength, 1,
"() -> (CFIndex _rv)"},
PyDoc_STR("() -> (CFIndex _rv)")},
{"CFStringCreateFromExternalRepresentation", (PyCFunction)CFDataRefObj_CFStringCreateFromExternalRepresentation, 1,
"(CFStringEncoding encoding) -> (CFStringRef _rv)"},
PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")},
{"CFDataGetData", (PyCFunction)CFDataRefObj_CFDataGetData, 1,
"() -> (string _rv)"},
PyDoc_STR("() -> (string _rv)")},
{NULL, NULL, 0}
};
@ -1361,15 +1361,15 @@ static PyObject *CFMutableDataRefObj_CFDataDeleteBytes(CFMutableDataRefObject *_
static PyMethodDef CFMutableDataRefObj_methods[] = {
{"CFDataSetLength", (PyCFunction)CFMutableDataRefObj_CFDataSetLength, 1,
"(CFIndex length) -> None"},
PyDoc_STR("(CFIndex length) -> None")},
{"CFDataIncreaseLength", (PyCFunction)CFMutableDataRefObj_CFDataIncreaseLength, 1,
"(CFIndex extraLength) -> None"},
PyDoc_STR("(CFIndex extraLength) -> None")},
{"CFDataAppendBytes", (PyCFunction)CFMutableDataRefObj_CFDataAppendBytes, 1,
"(Buffer bytes) -> None"},
PyDoc_STR("(Buffer bytes) -> None")},
{"CFDataReplaceBytes", (PyCFunction)CFMutableDataRefObj_CFDataReplaceBytes, 1,
"(CFRange range, Buffer newBytes) -> None"},
PyDoc_STR("(CFRange range, Buffer newBytes) -> None")},
{"CFDataDeleteBytes", (PyCFunction)CFMutableDataRefObj_CFDataDeleteBytes, 1,
"(CFRange range) -> None"},
PyDoc_STR("(CFRange range) -> None")},
{NULL, NULL, 0}
};
@ -2002,59 +2002,59 @@ static PyObject *CFStringRefObj_CFStringGetUnicode(CFStringRefObject *_self, PyO
static PyMethodDef CFStringRefObj_methods[] = {
{"CFStringCreateWithSubstring", (PyCFunction)CFStringRefObj_CFStringCreateWithSubstring, 1,
"(CFRange range) -> (CFStringRef _rv)"},
PyDoc_STR("(CFRange range) -> (CFStringRef _rv)")},
{"CFStringCreateCopy", (PyCFunction)CFStringRefObj_CFStringCreateCopy, 1,
"() -> (CFStringRef _rv)"},
PyDoc_STR("() -> (CFStringRef _rv)")},
{"CFStringGetLength", (PyCFunction)CFStringRefObj_CFStringGetLength, 1,
"() -> (CFIndex _rv)"},
PyDoc_STR("() -> (CFIndex _rv)")},
{"CFStringGetBytes", (PyCFunction)CFStringRefObj_CFStringGetBytes, 1,
"(CFRange range, CFStringEncoding encoding, UInt8 lossByte, Boolean isExternalRepresentation, CFIndex maxBufLen) -> (CFIndex _rv, UInt8 buffer, CFIndex usedBufLen)"},
PyDoc_STR("(CFRange range, CFStringEncoding encoding, UInt8 lossByte, Boolean isExternalRepresentation, CFIndex maxBufLen) -> (CFIndex _rv, UInt8 buffer, CFIndex usedBufLen)")},
{"CFStringCreateExternalRepresentation", (PyCFunction)CFStringRefObj_CFStringCreateExternalRepresentation, 1,
"(CFStringEncoding encoding, UInt8 lossByte) -> (CFDataRef _rv)"},
PyDoc_STR("(CFStringEncoding encoding, UInt8 lossByte) -> (CFDataRef _rv)")},
{"CFStringGetSmallestEncoding", (PyCFunction)CFStringRefObj_CFStringGetSmallestEncoding, 1,
"() -> (CFStringEncoding _rv)"},
PyDoc_STR("() -> (CFStringEncoding _rv)")},
{"CFStringGetFastestEncoding", (PyCFunction)CFStringRefObj_CFStringGetFastestEncoding, 1,
"() -> (CFStringEncoding _rv)"},
PyDoc_STR("() -> (CFStringEncoding _rv)")},
{"CFStringCompareWithOptions", (PyCFunction)CFStringRefObj_CFStringCompareWithOptions, 1,
"(CFStringRef theString2, CFRange rangeToCompare, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)"},
PyDoc_STR("(CFStringRef theString2, CFRange rangeToCompare, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)")},
{"CFStringCompare", (PyCFunction)CFStringRefObj_CFStringCompare, 1,
"(CFStringRef theString2, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)"},
PyDoc_STR("(CFStringRef theString2, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)")},
{"CFStringFindWithOptions", (PyCFunction)CFStringRefObj_CFStringFindWithOptions, 1,
"(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags searchOptions) -> (Boolean _rv, CFRange result)"},
PyDoc_STR("(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags searchOptions) -> (Boolean _rv, CFRange result)")},
{"CFStringCreateArrayWithFindResults", (PyCFunction)CFStringRefObj_CFStringCreateArrayWithFindResults, 1,
"(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags compareOptions) -> (CFArrayRef _rv)"},
PyDoc_STR("(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags compareOptions) -> (CFArrayRef _rv)")},
{"CFStringFind", (PyCFunction)CFStringRefObj_CFStringFind, 1,
"(CFStringRef stringToFind, CFOptionFlags compareOptions) -> (CFRange _rv)"},
PyDoc_STR("(CFStringRef stringToFind, CFOptionFlags compareOptions) -> (CFRange _rv)")},
{"CFStringHasPrefix", (PyCFunction)CFStringRefObj_CFStringHasPrefix, 1,
"(CFStringRef prefix) -> (Boolean _rv)"},
PyDoc_STR("(CFStringRef prefix) -> (Boolean _rv)")},
{"CFStringHasSuffix", (PyCFunction)CFStringRefObj_CFStringHasSuffix, 1,
"(CFStringRef suffix) -> (Boolean _rv)"},
PyDoc_STR("(CFStringRef suffix) -> (Boolean _rv)")},
{"CFStringGetLineBounds", (PyCFunction)CFStringRefObj_CFStringGetLineBounds, 1,
"(CFRange range) -> (CFIndex lineBeginIndex, CFIndex lineEndIndex, CFIndex contentsEndIndex)"},
PyDoc_STR("(CFRange range) -> (CFIndex lineBeginIndex, CFIndex lineEndIndex, CFIndex contentsEndIndex)")},
{"CFStringCreateArrayBySeparatingStrings", (PyCFunction)CFStringRefObj_CFStringCreateArrayBySeparatingStrings, 1,
"(CFStringRef separatorString) -> (CFArrayRef _rv)"},
PyDoc_STR("(CFStringRef separatorString) -> (CFArrayRef _rv)")},
{"CFStringGetIntValue", (PyCFunction)CFStringRefObj_CFStringGetIntValue, 1,
"() -> (SInt32 _rv)"},
PyDoc_STR("() -> (SInt32 _rv)")},
{"CFStringGetDoubleValue", (PyCFunction)CFStringRefObj_CFStringGetDoubleValue, 1,
"() -> (double _rv)"},
PyDoc_STR("() -> (double _rv)")},
{"CFStringConvertIANACharSetNameToEncoding", (PyCFunction)CFStringRefObj_CFStringConvertIANACharSetNameToEncoding, 1,
"() -> (CFStringEncoding _rv)"},
PyDoc_STR("() -> (CFStringEncoding _rv)")},
{"CFShowStr", (PyCFunction)CFStringRefObj_CFShowStr, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CFURLCreateWithString", (PyCFunction)CFStringRefObj_CFURLCreateWithString, 1,
"(CFURLRef baseURL) -> (CFURLRef _rv)"},
PyDoc_STR("(CFURLRef baseURL) -> (CFURLRef _rv)")},
{"CFURLCreateWithFileSystemPath", (PyCFunction)CFStringRefObj_CFURLCreateWithFileSystemPath, 1,
"(CFURLPathStyle pathStyle, Boolean isDirectory) -> (CFURLRef _rv)"},
PyDoc_STR("(CFURLPathStyle pathStyle, Boolean isDirectory) -> (CFURLRef _rv)")},
{"CFURLCreateWithFileSystemPathRelativeToBase", (PyCFunction)CFStringRefObj_CFURLCreateWithFileSystemPathRelativeToBase, 1,
"(CFURLPathStyle pathStyle, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)"},
PyDoc_STR("(CFURLPathStyle pathStyle, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)")},
{"CFURLCreateStringByReplacingPercentEscapes", (PyCFunction)CFStringRefObj_CFURLCreateStringByReplacingPercentEscapes, 1,
"(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"},
PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")},
{"CFURLCreateStringByAddingPercentEscapes", (PyCFunction)CFStringRefObj_CFURLCreateStringByAddingPercentEscapes, 1,
"(CFStringRef charactersToLeaveUnescaped, CFStringRef legalURLCharactersToBeEscaped, CFStringEncoding encoding) -> (CFStringRef _rv)"},
PyDoc_STR("(CFStringRef charactersToLeaveUnescaped, CFStringRef legalURLCharactersToBeEscaped, CFStringEncoding encoding) -> (CFStringRef _rv)")},
{"CFStringGetString", (PyCFunction)CFStringRefObj_CFStringGetString, 1,
"() -> (string _rv)"},
PyDoc_STR("() -> (string _rv)")},
{"CFStringGetUnicode", (PyCFunction)CFStringRefObj_CFStringGetUnicode, 1,
"() -> (unicode _rv)"},
PyDoc_STR("() -> (unicode _rv)")},
{NULL, NULL, 0}
};
@ -2367,27 +2367,27 @@ static PyObject *CFMutableStringRefObj_CFStringTrimWhitespace(CFMutableStringRef
static PyMethodDef CFMutableStringRefObj_methods[] = {
{"CFStringAppend", (PyCFunction)CFMutableStringRefObj_CFStringAppend, 1,
"(CFStringRef appendedString) -> None"},
PyDoc_STR("(CFStringRef appendedString) -> None")},
{"CFStringAppendCharacters", (PyCFunction)CFMutableStringRefObj_CFStringAppendCharacters, 1,
"(Buffer chars) -> None"},
PyDoc_STR("(Buffer chars) -> None")},
{"CFStringAppendPascalString", (PyCFunction)CFMutableStringRefObj_CFStringAppendPascalString, 1,
"(Str255 pStr, CFStringEncoding encoding) -> None"},
PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> None")},
{"CFStringAppendCString", (PyCFunction)CFMutableStringRefObj_CFStringAppendCString, 1,
"(char* cStr, CFStringEncoding encoding) -> None"},
PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> None")},
{"CFStringInsert", (PyCFunction)CFMutableStringRefObj_CFStringInsert, 1,
"(CFIndex idx, CFStringRef insertedStr) -> None"},
PyDoc_STR("(CFIndex idx, CFStringRef insertedStr) -> None")},
{"CFStringDelete", (PyCFunction)CFMutableStringRefObj_CFStringDelete, 1,
"(CFRange range) -> None"},
PyDoc_STR("(CFRange range) -> None")},
{"CFStringReplace", (PyCFunction)CFMutableStringRefObj_CFStringReplace, 1,
"(CFRange range, CFStringRef replacement) -> None"},
PyDoc_STR("(CFRange range, CFStringRef replacement) -> None")},
{"CFStringReplaceAll", (PyCFunction)CFMutableStringRefObj_CFStringReplaceAll, 1,
"(CFStringRef replacement) -> None"},
PyDoc_STR("(CFStringRef replacement) -> None")},
{"CFStringPad", (PyCFunction)CFMutableStringRefObj_CFStringPad, 1,
"(CFStringRef padString, CFIndex length, CFIndex indexIntoPad) -> None"},
PyDoc_STR("(CFStringRef padString, CFIndex length, CFIndex indexIntoPad) -> None")},
{"CFStringTrim", (PyCFunction)CFMutableStringRefObj_CFStringTrim, 1,
"(CFStringRef trimString) -> None"},
PyDoc_STR("(CFStringRef trimString) -> None")},
{"CFStringTrimWhitespace", (PyCFunction)CFMutableStringRefObj_CFStringTrimWhitespace, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{NULL, NULL, 0}
};
@ -2932,59 +2932,59 @@ static PyObject *CFURLRefObj_CFURLGetFSRef(CFURLRefObject *_self, PyObject *_arg
static PyMethodDef CFURLRefObj_methods[] = {
{"CFURLCreateData", (PyCFunction)CFURLRefObj_CFURLCreateData, 1,
"(CFStringEncoding encoding, Boolean escapeWhitespace) -> (CFDataRef _rv)"},
PyDoc_STR("(CFStringEncoding encoding, Boolean escapeWhitespace) -> (CFDataRef _rv)")},
{"CFURLGetFileSystemRepresentation", (PyCFunction)CFURLRefObj_CFURLGetFileSystemRepresentation, 1,
"(Boolean resolveAgainstBase, CFIndex maxBufLen) -> (Boolean _rv, UInt8 buffer)"},
PyDoc_STR("(Boolean resolveAgainstBase, CFIndex maxBufLen) -> (Boolean _rv, UInt8 buffer)")},
{"CFURLCopyAbsoluteURL", (PyCFunction)CFURLRefObj_CFURLCopyAbsoluteURL, 1,
"() -> (CFURLRef _rv)"},
PyDoc_STR("() -> (CFURLRef _rv)")},
{"CFURLGetString", (PyCFunction)CFURLRefObj_CFURLGetString, 1,
"() -> (CFStringRef _rv)"},
PyDoc_STR("() -> (CFStringRef _rv)")},
{"CFURLGetBaseURL", (PyCFunction)CFURLRefObj_CFURLGetBaseURL, 1,
"() -> (CFURLRef _rv)"},
PyDoc_STR("() -> (CFURLRef _rv)")},
{"CFURLCanBeDecomposed", (PyCFunction)CFURLRefObj_CFURLCanBeDecomposed, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
{"CFURLCopyScheme", (PyCFunction)CFURLRefObj_CFURLCopyScheme, 1,
"() -> (CFStringRef _rv)"},
PyDoc_STR("() -> (CFStringRef _rv)")},
{"CFURLCopyNetLocation", (PyCFunction)CFURLRefObj_CFURLCopyNetLocation, 1,
"() -> (CFStringRef _rv)"},
PyDoc_STR("() -> (CFStringRef _rv)")},
{"CFURLCopyPath", (PyCFunction)CFURLRefObj_CFURLCopyPath, 1,
"() -> (CFStringRef _rv)"},
PyDoc_STR("() -> (CFStringRef _rv)")},
{"CFURLCopyStrictPath", (PyCFunction)CFURLRefObj_CFURLCopyStrictPath, 1,
"() -> (CFStringRef _rv, Boolean isAbsolute)"},
PyDoc_STR("() -> (CFStringRef _rv, Boolean isAbsolute)")},
{"CFURLCopyFileSystemPath", (PyCFunction)CFURLRefObj_CFURLCopyFileSystemPath, 1,
"(CFURLPathStyle pathStyle) -> (CFStringRef _rv)"},
PyDoc_STR("(CFURLPathStyle pathStyle) -> (CFStringRef _rv)")},
{"CFURLHasDirectoryPath", (PyCFunction)CFURLRefObj_CFURLHasDirectoryPath, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
{"CFURLCopyResourceSpecifier", (PyCFunction)CFURLRefObj_CFURLCopyResourceSpecifier, 1,
"() -> (CFStringRef _rv)"},
PyDoc_STR("() -> (CFStringRef _rv)")},
{"CFURLCopyHostName", (PyCFunction)CFURLRefObj_CFURLCopyHostName, 1,
"() -> (CFStringRef _rv)"},
PyDoc_STR("() -> (CFStringRef _rv)")},
{"CFURLGetPortNumber", (PyCFunction)CFURLRefObj_CFURLGetPortNumber, 1,
"() -> (SInt32 _rv)"},
PyDoc_STR("() -> (SInt32 _rv)")},
{"CFURLCopyUserName", (PyCFunction)CFURLRefObj_CFURLCopyUserName, 1,
"() -> (CFStringRef _rv)"},
PyDoc_STR("() -> (CFStringRef _rv)")},
{"CFURLCopyPassword", (PyCFunction)CFURLRefObj_CFURLCopyPassword, 1,
"() -> (CFStringRef _rv)"},
PyDoc_STR("() -> (CFStringRef _rv)")},
{"CFURLCopyParameterString", (PyCFunction)CFURLRefObj_CFURLCopyParameterString, 1,
"(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"},
PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")},
{"CFURLCopyQueryString", (PyCFunction)CFURLRefObj_CFURLCopyQueryString, 1,
"(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"},
PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")},
{"CFURLCopyFragment", (PyCFunction)CFURLRefObj_CFURLCopyFragment, 1,
"(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"},
PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")},
{"CFURLCopyLastPathComponent", (PyCFunction)CFURLRefObj_CFURLCopyLastPathComponent, 1,
"() -> (CFStringRef _rv)"},
PyDoc_STR("() -> (CFStringRef _rv)")},
{"CFURLCopyPathExtension", (PyCFunction)CFURLRefObj_CFURLCopyPathExtension, 1,
"() -> (CFStringRef _rv)"},
PyDoc_STR("() -> (CFStringRef _rv)")},
{"CFURLCreateCopyAppendingPathComponent", (PyCFunction)CFURLRefObj_CFURLCreateCopyAppendingPathComponent, 1,
"(CFStringRef pathComponent, Boolean isDirectory) -> (CFURLRef _rv)"},
PyDoc_STR("(CFStringRef pathComponent, Boolean isDirectory) -> (CFURLRef _rv)")},
{"CFURLCreateCopyDeletingLastPathComponent", (PyCFunction)CFURLRefObj_CFURLCreateCopyDeletingLastPathComponent, 1,
"() -> (CFURLRef _rv)"},
PyDoc_STR("() -> (CFURLRef _rv)")},
{"CFURLCreateCopyAppendingPathExtension", (PyCFunction)CFURLRefObj_CFURLCreateCopyAppendingPathExtension, 1,
"(CFStringRef extension) -> (CFURLRef _rv)"},
PyDoc_STR("(CFStringRef extension) -> (CFURLRef _rv)")},
{"CFURLCreateCopyDeletingPathExtension", (PyCFunction)CFURLRefObj_CFURLCreateCopyDeletingPathExtension, 1,
"() -> (CFURLRef _rv)"},
PyDoc_STR("() -> (CFURLRef _rv)")},
{"CFURLGetFSRef", (PyCFunction)CFURLRefObj_CFURLGetFSRef, 1,
"() -> (Boolean _rv, FSRef fsRef)"},
PyDoc_STR("() -> (Boolean _rv, FSRef fsRef)")},
{NULL, NULL, 0}
};
@ -4173,117 +4173,117 @@ static PyObject *CF_toCF(PyObject *_self, PyObject *_args)
static PyMethodDef CF_methods[] = {
{"__CFRangeMake", (PyCFunction)CF___CFRangeMake, 1,
"(CFIndex loc, CFIndex len) -> (CFRange _rv)"},
PyDoc_STR("(CFIndex loc, CFIndex len) -> (CFRange _rv)")},
{"CFAllocatorGetTypeID", (PyCFunction)CF_CFAllocatorGetTypeID, 1,
"() -> (CFTypeID _rv)"},
PyDoc_STR("() -> (CFTypeID _rv)")},
{"CFAllocatorGetPreferredSizeForSize", (PyCFunction)CF_CFAllocatorGetPreferredSizeForSize, 1,
"(CFIndex size, CFOptionFlags hint) -> (CFIndex _rv)"},
PyDoc_STR("(CFIndex size, CFOptionFlags hint) -> (CFIndex _rv)")},
{"CFCopyTypeIDDescription", (PyCFunction)CF_CFCopyTypeIDDescription, 1,
"(CFTypeID type_id) -> (CFStringRef _rv)"},
PyDoc_STR("(CFTypeID type_id) -> (CFStringRef _rv)")},
{"CFArrayGetTypeID", (PyCFunction)CF_CFArrayGetTypeID, 1,
"() -> (CFTypeID _rv)"},
PyDoc_STR("() -> (CFTypeID _rv)")},
{"CFArrayCreateMutable", (PyCFunction)CF_CFArrayCreateMutable, 1,
"(CFIndex capacity) -> (CFMutableArrayRef _rv)"},
PyDoc_STR("(CFIndex capacity) -> (CFMutableArrayRef _rv)")},
{"CFArrayCreateMutableCopy", (PyCFunction)CF_CFArrayCreateMutableCopy, 1,
"(CFIndex capacity, CFArrayRef theArray) -> (CFMutableArrayRef _rv)"},
PyDoc_STR("(CFIndex capacity, CFArrayRef theArray) -> (CFMutableArrayRef _rv)")},
{"CFDataGetTypeID", (PyCFunction)CF_CFDataGetTypeID, 1,
"() -> (CFTypeID _rv)"},
PyDoc_STR("() -> (CFTypeID _rv)")},
{"CFDataCreate", (PyCFunction)CF_CFDataCreate, 1,
"(Buffer bytes) -> (CFDataRef _rv)"},
PyDoc_STR("(Buffer bytes) -> (CFDataRef _rv)")},
{"CFDataCreateWithBytesNoCopy", (PyCFunction)CF_CFDataCreateWithBytesNoCopy, 1,
"(Buffer bytes) -> (CFDataRef _rv)"},
PyDoc_STR("(Buffer bytes) -> (CFDataRef _rv)")},
{"CFDataCreateMutable", (PyCFunction)CF_CFDataCreateMutable, 1,
"(CFIndex capacity) -> (CFMutableDataRef _rv)"},
PyDoc_STR("(CFIndex capacity) -> (CFMutableDataRef _rv)")},
{"CFDataCreateMutableCopy", (PyCFunction)CF_CFDataCreateMutableCopy, 1,
"(CFIndex capacity, CFDataRef theData) -> (CFMutableDataRef _rv)"},
PyDoc_STR("(CFIndex capacity, CFDataRef theData) -> (CFMutableDataRef _rv)")},
{"CFDictionaryGetTypeID", (PyCFunction)CF_CFDictionaryGetTypeID, 1,
"() -> (CFTypeID _rv)"},
PyDoc_STR("() -> (CFTypeID _rv)")},
{"CFDictionaryCreateMutable", (PyCFunction)CF_CFDictionaryCreateMutable, 1,
"(CFIndex capacity) -> (CFMutableDictionaryRef _rv)"},
PyDoc_STR("(CFIndex capacity) -> (CFMutableDictionaryRef _rv)")},
{"CFDictionaryCreateMutableCopy", (PyCFunction)CF_CFDictionaryCreateMutableCopy, 1,
"(CFIndex capacity, CFDictionaryRef theDict) -> (CFMutableDictionaryRef _rv)"},
PyDoc_STR("(CFIndex capacity, CFDictionaryRef theDict) -> (CFMutableDictionaryRef _rv)")},
{"CFPreferencesCopyAppValue", (PyCFunction)CF_CFPreferencesCopyAppValue, 1,
"(CFStringRef key, CFStringRef applicationID) -> (CFTypeRef _rv)"},
PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (CFTypeRef _rv)")},
{"CFPreferencesGetAppBooleanValue", (PyCFunction)CF_CFPreferencesGetAppBooleanValue, 1,
"(CFStringRef key, CFStringRef applicationID) -> (Boolean _rv, Boolean keyExistsAndHasValidFormat)"},
PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (Boolean _rv, Boolean keyExistsAndHasValidFormat)")},
{"CFPreferencesGetAppIntegerValue", (PyCFunction)CF_CFPreferencesGetAppIntegerValue, 1,
"(CFStringRef key, CFStringRef applicationID) -> (CFIndex _rv, Boolean keyExistsAndHasValidFormat)"},
PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (CFIndex _rv, Boolean keyExistsAndHasValidFormat)")},
{"CFPreferencesSetAppValue", (PyCFunction)CF_CFPreferencesSetAppValue, 1,
"(CFStringRef key, CFTypeRef value, CFStringRef applicationID) -> None"},
PyDoc_STR("(CFStringRef key, CFTypeRef value, CFStringRef applicationID) -> None")},
{"CFPreferencesAddSuitePreferencesToApp", (PyCFunction)CF_CFPreferencesAddSuitePreferencesToApp, 1,
"(CFStringRef applicationID, CFStringRef suiteID) -> None"},
PyDoc_STR("(CFStringRef applicationID, CFStringRef suiteID) -> None")},
{"CFPreferencesRemoveSuitePreferencesFromApp", (PyCFunction)CF_CFPreferencesRemoveSuitePreferencesFromApp, 1,
"(CFStringRef applicationID, CFStringRef suiteID) -> None"},
PyDoc_STR("(CFStringRef applicationID, CFStringRef suiteID) -> None")},
{"CFPreferencesAppSynchronize", (PyCFunction)CF_CFPreferencesAppSynchronize, 1,
"(CFStringRef applicationID) -> (Boolean _rv)"},
PyDoc_STR("(CFStringRef applicationID) -> (Boolean _rv)")},
{"CFPreferencesCopyValue", (PyCFunction)CF_CFPreferencesCopyValue, 1,
"(CFStringRef key, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFTypeRef _rv)"},
PyDoc_STR("(CFStringRef key, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFTypeRef _rv)")},
{"CFPreferencesCopyMultiple", (PyCFunction)CF_CFPreferencesCopyMultiple, 1,
"(CFArrayRef keysToFetch, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFDictionaryRef _rv)"},
PyDoc_STR("(CFArrayRef keysToFetch, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFDictionaryRef _rv)")},
{"CFPreferencesSetValue", (PyCFunction)CF_CFPreferencesSetValue, 1,
"(CFStringRef key, CFTypeRef value, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None"},
PyDoc_STR("(CFStringRef key, CFTypeRef value, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None")},
{"CFPreferencesSetMultiple", (PyCFunction)CF_CFPreferencesSetMultiple, 1,
"(CFDictionaryRef keysToSet, CFArrayRef keysToRemove, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None"},
PyDoc_STR("(CFDictionaryRef keysToSet, CFArrayRef keysToRemove, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None")},
{"CFPreferencesSynchronize", (PyCFunction)CF_CFPreferencesSynchronize, 1,
"(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (Boolean _rv)"},
PyDoc_STR("(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (Boolean _rv)")},
{"CFPreferencesCopyApplicationList", (PyCFunction)CF_CFPreferencesCopyApplicationList, 1,
"(CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)"},
PyDoc_STR("(CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)")},
{"CFPreferencesCopyKeyList", (PyCFunction)CF_CFPreferencesCopyKeyList, 1,
"(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)"},
PyDoc_STR("(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)")},
{"CFStringGetTypeID", (PyCFunction)CF_CFStringGetTypeID, 1,
"() -> (CFTypeID _rv)"},
PyDoc_STR("() -> (CFTypeID _rv)")},
{"CFStringCreateWithPascalString", (PyCFunction)CF_CFStringCreateWithPascalString, 1,
"(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)")},
{"CFStringCreateWithCString", (PyCFunction)CF_CFStringCreateWithCString, 1,
"(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)")},
{"CFStringCreateWithCharacters", (PyCFunction)CF_CFStringCreateWithCharacters, 1,
"(Buffer chars) -> (CFStringRef _rv)"},
PyDoc_STR("(Buffer chars) -> (CFStringRef _rv)")},
{"CFStringCreateWithPascalStringNoCopy", (PyCFunction)CF_CFStringCreateWithPascalStringNoCopy, 1,
"(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)")},
{"CFStringCreateWithCStringNoCopy", (PyCFunction)CF_CFStringCreateWithCStringNoCopy, 1,
"(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)")},
{"CFStringCreateWithCharactersNoCopy", (PyCFunction)CF_CFStringCreateWithCharactersNoCopy, 1,
"(Buffer chars) -> (CFStringRef _rv)"},
PyDoc_STR("(Buffer chars) -> (CFStringRef _rv)")},
{"CFStringCreateMutable", (PyCFunction)CF_CFStringCreateMutable, 1,
"(CFIndex maxLength) -> (CFMutableStringRef _rv)"},
PyDoc_STR("(CFIndex maxLength) -> (CFMutableStringRef _rv)")},
{"CFStringCreateMutableCopy", (PyCFunction)CF_CFStringCreateMutableCopy, 1,
"(CFIndex maxLength, CFStringRef theString) -> (CFMutableStringRef _rv)"},
PyDoc_STR("(CFIndex maxLength, CFStringRef theString) -> (CFMutableStringRef _rv)")},
{"CFStringCreateWithBytes", (PyCFunction)CF_CFStringCreateWithBytes, 1,
"(Buffer bytes, CFStringEncoding encoding, Boolean isExternalRepresentation) -> (CFStringRef _rv)"},
PyDoc_STR("(Buffer bytes, CFStringEncoding encoding, Boolean isExternalRepresentation) -> (CFStringRef _rv)")},
{"CFStringGetSystemEncoding", (PyCFunction)CF_CFStringGetSystemEncoding, 1,
"() -> (CFStringEncoding _rv)"},
PyDoc_STR("() -> (CFStringEncoding _rv)")},
{"CFStringGetMaximumSizeForEncoding", (PyCFunction)CF_CFStringGetMaximumSizeForEncoding, 1,
"(CFIndex length, CFStringEncoding encoding) -> (CFIndex _rv)"},
PyDoc_STR("(CFIndex length, CFStringEncoding encoding) -> (CFIndex _rv)")},
{"CFStringIsEncodingAvailable", (PyCFunction)CF_CFStringIsEncodingAvailable, 1,
"(CFStringEncoding encoding) -> (Boolean _rv)"},
PyDoc_STR("(CFStringEncoding encoding) -> (Boolean _rv)")},
{"CFStringGetNameOfEncoding", (PyCFunction)CF_CFStringGetNameOfEncoding, 1,
"(CFStringEncoding encoding) -> (CFStringRef _rv)"},
PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")},
{"CFStringConvertEncodingToNSStringEncoding", (PyCFunction)CF_CFStringConvertEncodingToNSStringEncoding, 1,
"(CFStringEncoding encoding) -> (UInt32 _rv)"},
PyDoc_STR("(CFStringEncoding encoding) -> (UInt32 _rv)")},
{"CFStringConvertNSStringEncodingToEncoding", (PyCFunction)CF_CFStringConvertNSStringEncodingToEncoding, 1,
"(UInt32 encoding) -> (CFStringEncoding _rv)"},
PyDoc_STR("(UInt32 encoding) -> (CFStringEncoding _rv)")},
{"CFStringConvertEncodingToWindowsCodepage", (PyCFunction)CF_CFStringConvertEncodingToWindowsCodepage, 1,
"(CFStringEncoding encoding) -> (UInt32 _rv)"},
PyDoc_STR("(CFStringEncoding encoding) -> (UInt32 _rv)")},
{"CFStringConvertWindowsCodepageToEncoding", (PyCFunction)CF_CFStringConvertWindowsCodepageToEncoding, 1,
"(UInt32 codepage) -> (CFStringEncoding _rv)"},
PyDoc_STR("(UInt32 codepage) -> (CFStringEncoding _rv)")},
{"CFStringConvertEncodingToIANACharSetName", (PyCFunction)CF_CFStringConvertEncodingToIANACharSetName, 1,
"(CFStringEncoding encoding) -> (CFStringRef _rv)"},
PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")},
{"CFStringGetMostCompatibleMacStringEncoding", (PyCFunction)CF_CFStringGetMostCompatibleMacStringEncoding, 1,
"(CFStringEncoding encoding) -> (CFStringEncoding _rv)"},
PyDoc_STR("(CFStringEncoding encoding) -> (CFStringEncoding _rv)")},
{"__CFStringMakeConstantString", (PyCFunction)CF___CFStringMakeConstantString, 1,
"(char* cStr) -> (CFStringRef _rv)"},
PyDoc_STR("(char* cStr) -> (CFStringRef _rv)")},
{"CFURLGetTypeID", (PyCFunction)CF_CFURLGetTypeID, 1,
"() -> (CFTypeID _rv)"},
PyDoc_STR("() -> (CFTypeID _rv)")},
{"CFURLCreateWithBytes", (PyCFunction)CF_CFURLCreateWithBytes, 1,
"(Buffer URLBytes, CFStringEncoding encoding, CFURLRef baseURL) -> (CFURLRef _rv)"},
PyDoc_STR("(Buffer URLBytes, CFStringEncoding encoding, CFURLRef baseURL) -> (CFURLRef _rv)")},
{"CFURLCreateFromFileSystemRepresentation", (PyCFunction)CF_CFURLCreateFromFileSystemRepresentation, 1,
"(Buffer buffer, Boolean isDirectory) -> (CFURLRef _rv)"},
PyDoc_STR("(Buffer buffer, Boolean isDirectory) -> (CFURLRef _rv)")},
{"CFURLCreateFromFileSystemRepresentationRelativeToBase", (PyCFunction)CF_CFURLCreateFromFileSystemRepresentationRelativeToBase, 1,
"(Buffer buffer, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)"},
PyDoc_STR("(Buffer buffer, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)")},
{"CFURLCreateFromFSRef", (PyCFunction)CF_CFURLCreateFromFSRef, 1,
"(FSRef fsRef) -> (CFURLRef _rv)"},
PyDoc_STR("(FSRef fsRef) -> (CFURLRef _rv)")},
{"toCF", (PyCFunction)CF_toCF, 1,
"(python_object) -> (CF_object)"},
PyDoc_STR("(python_object) -> (CF_object)")},
{NULL, NULL, 0}
};

118
Mac/Modules/cg/_CGmodule.c
View File

@ -1148,121 +1148,121 @@ static PyObject *CGContextRefObj_ClipCGContextToRegion(CGContextRefObject *_self
static PyMethodDef CGContextRefObj_methods[] = {
{"CGContextSaveGState", (PyCFunction)CGContextRefObj_CGContextSaveGState, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CGContextRestoreGState", (PyCFunction)CGContextRefObj_CGContextRestoreGState, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CGContextScaleCTM", (PyCFunction)CGContextRefObj_CGContextScaleCTM, 1,
"(float sx, float sy) -> None"},
PyDoc_STR("(float sx, float sy) -> None")},
{"CGContextTranslateCTM", (PyCFunction)CGContextRefObj_CGContextTranslateCTM, 1,
"(float tx, float ty) -> None"},
PyDoc_STR("(float tx, float ty) -> None")},
{"CGContextRotateCTM", (PyCFunction)CGContextRefObj_CGContextRotateCTM, 1,
"(float angle) -> None"},
PyDoc_STR("(float angle) -> None")},
{"CGContextConcatCTM", (PyCFunction)CGContextRefObj_CGContextConcatCTM, 1,
"(CGAffineTransform transform) -> None"},
PyDoc_STR("(CGAffineTransform transform) -> None")},
{"CGContextGetCTM", (PyCFunction)CGContextRefObj_CGContextGetCTM, 1,
"() -> (CGAffineTransform _rv)"},
PyDoc_STR("() -> (CGAffineTransform _rv)")},
{"CGContextSetLineWidth", (PyCFunction)CGContextRefObj_CGContextSetLineWidth, 1,
"(float width) -> None"},
PyDoc_STR("(float width) -> None")},
{"CGContextSetLineCap", (PyCFunction)CGContextRefObj_CGContextSetLineCap, 1,
"(int cap) -> None"},
PyDoc_STR("(int cap) -> None")},
{"CGContextSetLineJoin", (PyCFunction)CGContextRefObj_CGContextSetLineJoin, 1,
"(int join) -> None"},
PyDoc_STR("(int join) -> None")},
{"CGContextSetMiterLimit", (PyCFunction)CGContextRefObj_CGContextSetMiterLimit, 1,
"(float limit) -> None"},
PyDoc_STR("(float limit) -> None")},
{"CGContextSetFlatness", (PyCFunction)CGContextRefObj_CGContextSetFlatness, 1,
"(float flatness) -> None"},
PyDoc_STR("(float flatness) -> None")},
{"CGContextSetAlpha", (PyCFunction)CGContextRefObj_CGContextSetAlpha, 1,
"(float alpha) -> None"},
PyDoc_STR("(float alpha) -> None")},
{"CGContextBeginPath", (PyCFunction)CGContextRefObj_CGContextBeginPath, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CGContextMoveToPoint", (PyCFunction)CGContextRefObj_CGContextMoveToPoint, 1,
"(float x, float y) -> None"},
PyDoc_STR("(float x, float y) -> None")},
{"CGContextAddLineToPoint", (PyCFunction)CGContextRefObj_CGContextAddLineToPoint, 1,
"(float x, float y) -> None"},
PyDoc_STR("(float x, float y) -> None")},
{"CGContextAddCurveToPoint", (PyCFunction)CGContextRefObj_CGContextAddCurveToPoint, 1,
"(float cp1x, float cp1y, float cp2x, float cp2y, float x, float y) -> None"},
PyDoc_STR("(float cp1x, float cp1y, float cp2x, float cp2y, float x, float y) -> None")},
{"CGContextAddQuadCurveToPoint", (PyCFunction)CGContextRefObj_CGContextAddQuadCurveToPoint, 1,
"(float cpx, float cpy, float x, float y) -> None"},
PyDoc_STR("(float cpx, float cpy, float x, float y) -> None")},
{"CGContextClosePath", (PyCFunction)CGContextRefObj_CGContextClosePath, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CGContextAddRect", (PyCFunction)CGContextRefObj_CGContextAddRect, 1,
"(CGRect rect) -> None"},
PyDoc_STR("(CGRect rect) -> None")},
{"CGContextAddArc", (PyCFunction)CGContextRefObj_CGContextAddArc, 1,
"(float x, float y, float radius, float startAngle, float endAngle, int clockwise) -> None"},
PyDoc_STR("(float x, float y, float radius, float startAngle, float endAngle, int clockwise) -> None")},
{"CGContextAddArcToPoint", (PyCFunction)CGContextRefObj_CGContextAddArcToPoint, 1,
"(float x1, float y1, float x2, float y2, float radius) -> None"},
PyDoc_STR("(float x1, float y1, float x2, float y2, float radius) -> None")},
{"CGContextIsPathEmpty", (PyCFunction)CGContextRefObj_CGContextIsPathEmpty, 1,
"() -> (int _rv)"},
PyDoc_STR("() -> (int _rv)")},
{"CGContextGetPathCurrentPoint", (PyCFunction)CGContextRefObj_CGContextGetPathCurrentPoint, 1,
"() -> (CGPoint _rv)"},
PyDoc_STR("() -> (CGPoint _rv)")},
{"CGContextGetPathBoundingBox", (PyCFunction)CGContextRefObj_CGContextGetPathBoundingBox, 1,
"() -> (CGRect _rv)"},
PyDoc_STR("() -> (CGRect _rv)")},
{"CGContextDrawPath", (PyCFunction)CGContextRefObj_CGContextDrawPath, 1,
"(int mode) -> None"},
PyDoc_STR("(int mode) -> None")},
{"CGContextFillPath", (PyCFunction)CGContextRefObj_CGContextFillPath, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CGContextEOFillPath", (PyCFunction)CGContextRefObj_CGContextEOFillPath, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CGContextStrokePath", (PyCFunction)CGContextRefObj_CGContextStrokePath, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CGContextFillRect", (PyCFunction)CGContextRefObj_CGContextFillRect, 1,
"(CGRect rect) -> None"},
PyDoc_STR("(CGRect rect) -> None")},
{"CGContextStrokeRect", (PyCFunction)CGContextRefObj_CGContextStrokeRect, 1,
"(CGRect rect) -> None"},
PyDoc_STR("(CGRect rect) -> None")},
{"CGContextStrokeRectWithWidth", (PyCFunction)CGContextRefObj_CGContextStrokeRectWithWidth, 1,
"(CGRect rect, float width) -> None"},
PyDoc_STR("(CGRect rect, float width) -> None")},
{"CGContextClearRect", (PyCFunction)CGContextRefObj_CGContextClearRect, 1,
"(CGRect rect) -> None"},
PyDoc_STR("(CGRect rect) -> None")},
{"CGContextClip", (PyCFunction)CGContextRefObj_CGContextClip, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CGContextEOClip", (PyCFunction)CGContextRefObj_CGContextEOClip, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CGContextClipToRect", (PyCFunction)CGContextRefObj_CGContextClipToRect, 1,
"(CGRect rect) -> None"},
PyDoc_STR("(CGRect rect) -> None")},
{"CGContextSetGrayFillColor", (PyCFunction)CGContextRefObj_CGContextSetGrayFillColor, 1,
"(float gray, float alpha) -> None"},
PyDoc_STR("(float gray, float alpha) -> None")},
{"CGContextSetGrayStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetGrayStrokeColor, 1,
"(float gray, float alpha) -> None"},
PyDoc_STR("(float gray, float alpha) -> None")},
{"CGContextSetRGBFillColor", (PyCFunction)CGContextRefObj_CGContextSetRGBFillColor, 1,
"(float r, float g, float b, float alpha) -> None"},
PyDoc_STR("(float r, float g, float b, float alpha) -> None")},
{"CGContextSetRGBStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetRGBStrokeColor, 1,
"(float r, float g, float b, float alpha) -> None"},
PyDoc_STR("(float r, float g, float b, float alpha) -> None")},
{"CGContextSetCMYKFillColor", (PyCFunction)CGContextRefObj_CGContextSetCMYKFillColor, 1,
"(float c, float m, float y, float k, float alpha) -> None"},
PyDoc_STR("(float c, float m, float y, float k, float alpha) -> None")},
{"CGContextSetCMYKStrokeColor", (PyCFunction)CGContextRefObj_CGContextSetCMYKStrokeColor, 1,
"(float c, float m, float y, float k, float alpha) -> None"},
PyDoc_STR("(float c, float m, float y, float k, float alpha) -> None")},
{"CGContextSetCharacterSpacing", (PyCFunction)CGContextRefObj_CGContextSetCharacterSpacing, 1,
"(float spacing) -> None"},
PyDoc_STR("(float spacing) -> None")},
{"CGContextSetTextPosition", (PyCFunction)CGContextRefObj_CGContextSetTextPosition, 1,
"(float x, float y) -> None"},
PyDoc_STR("(float x, float y) -> None")},
{"CGContextGetTextPosition", (PyCFunction)CGContextRefObj_CGContextGetTextPosition, 1,
"() -> (CGPoint _rv)"},
PyDoc_STR("() -> (CGPoint _rv)")},
{"CGContextSetTextMatrix", (PyCFunction)CGContextRefObj_CGContextSetTextMatrix, 1,
"(CGAffineTransform transform) -> None"},
PyDoc_STR("(CGAffineTransform transform) -> None")},
{"CGContextGetTextMatrix", (PyCFunction)CGContextRefObj_CGContextGetTextMatrix, 1,
"() -> (CGAffineTransform _rv)"},
PyDoc_STR("() -> (CGAffineTransform _rv)")},
{"CGContextSetTextDrawingMode", (PyCFunction)CGContextRefObj_CGContextSetTextDrawingMode, 1,
"(int mode) -> None"},
PyDoc_STR("(int mode) -> None")},
{"CGContextSetFontSize", (PyCFunction)CGContextRefObj_CGContextSetFontSize, 1,
"(float size) -> None"},
PyDoc_STR("(float size) -> None")},
{"CGContextSelectFont", (PyCFunction)CGContextRefObj_CGContextSelectFont, 1,
"(char * name, float size, int textEncoding) -> None"},
PyDoc_STR("(char * name, float size, int textEncoding) -> None")},
{"CGContextShowText", (PyCFunction)CGContextRefObj_CGContextShowText, 1,
"(Buffer cstring) -> None"},
PyDoc_STR("(Buffer cstring) -> None")},
{"CGContextShowTextAtPoint", (PyCFunction)CGContextRefObj_CGContextShowTextAtPoint, 1,
"(float x, float y, Buffer cstring) -> None"},
PyDoc_STR("(float x, float y, Buffer cstring) -> None")},
{"CGContextEndPage", (PyCFunction)CGContextRefObj_CGContextEndPage, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CGContextFlush", (PyCFunction)CGContextRefObj_CGContextFlush, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CGContextSynchronize", (PyCFunction)CGContextRefObj_CGContextSynchronize, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CGContextSetShouldAntialias", (PyCFunction)CGContextRefObj_CGContextSetShouldAntialias, 1,
"(int shouldAntialias) -> None"},
PyDoc_STR("(int shouldAntialias) -> None")},
{"SyncCGContextOriginWithPort", (PyCFunction)CGContextRefObj_SyncCGContextOriginWithPort, 1,
"(CGrafPtr port) -> None"},
PyDoc_STR("(CGrafPtr port) -> None")},
{"ClipCGContextToRegion", (PyCFunction)CGContextRefObj_ClipCGContextToRegion, 1,
"(Rect portRect, RgnHandle region) -> None"},
PyDoc_STR("(Rect portRect, RgnHandle region) -> None")},
{NULL, NULL, 0}
};
@ -1323,7 +1323,7 @@ static PyObject *CG_CreateCGContextForPort(PyObject *_self, PyObject *_args)
static PyMethodDef CG_methods[] = {
{"CreateCGContextForPort", (PyCFunction)CG_CreateCGContextForPort, 1,
"(CGrafPtr) -> CGContextRef"},
PyDoc_STR("(CGrafPtr) -> CGContextRef")},
{NULL, NULL, 0}
};

64
Mac/Modules/cm/_Cmmodule.c
View File

@ -277,31 +277,31 @@ static PyObject *CmpInstObj_ComponentSetTarget(ComponentInstanceObject *_self, P
static PyMethodDef CmpInstObj_methods[] = {
{"CloseComponent", (PyCFunction)CmpInstObj_CloseComponent, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"GetComponentInstanceError", (PyCFunction)CmpInstObj_GetComponentInstanceError, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"SetComponentInstanceError", (PyCFunction)CmpInstObj_SetComponentInstanceError, 1,
"(OSErr theError) -> None"},
PyDoc_STR("(OSErr theError) -> None")},
{"GetComponentInstanceStorage", (PyCFunction)CmpInstObj_GetComponentInstanceStorage, 1,
"() -> (Handle _rv)"},
PyDoc_STR("() -> (Handle _rv)")},
{"SetComponentInstanceStorage", (PyCFunction)CmpInstObj_SetComponentInstanceStorage, 1,
"(Handle theStorage) -> None"},
PyDoc_STR("(Handle theStorage) -> None")},
#if !TARGET_API_MAC_CARBON
{"GetComponentInstanceA5", (PyCFunction)CmpInstObj_GetComponentInstanceA5, 1,
"() -> (long _rv)"},
PyDoc_STR("() -> (long _rv)")},
#endif
#if !TARGET_API_MAC_CARBON
{"SetComponentInstanceA5", (PyCFunction)CmpInstObj_SetComponentInstanceA5, 1,
"(long theA5) -> None"},
PyDoc_STR("(long theA5) -> None")},
#endif
{"ComponentFunctionImplemented", (PyCFunction)CmpInstObj_ComponentFunctionImplemented, 1,
"(short ftnNumber) -> (long _rv)"},
PyDoc_STR("(short ftnNumber) -> (long _rv)")},
{"GetComponentVersion", (PyCFunction)CmpInstObj_GetComponentVersion, 1,
"() -> (long _rv)"},
PyDoc_STR("() -> (long _rv)")},
{"ComponentSetTarget", (PyCFunction)CmpInstObj_ComponentSetTarget, 1,
"(ComponentInstance target) -> (long _rv)"},
PyDoc_STR("(ComponentInstance target) -> (long _rv)")},
{NULL, NULL, 0}
};
@ -669,35 +669,35 @@ static PyObject *CmpObj_GetComponentIconSuite(ComponentObject *_self, PyObject *
static PyMethodDef CmpObj_methods[] = {
{"UnregisterComponent", (PyCFunction)CmpObj_UnregisterComponent, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"GetComponentInfo", (PyCFunction)CmpObj_GetComponentInfo, 1,
"(Handle componentName, Handle componentInfo, Handle componentIcon) -> (ComponentDescription cd)"},
PyDoc_STR("(Handle componentName, Handle componentInfo, Handle componentIcon) -> (ComponentDescription cd)")},
{"OpenComponent", (PyCFunction)CmpObj_OpenComponent, 1,
"() -> (ComponentInstance _rv)"},
PyDoc_STR("() -> (ComponentInstance _rv)")},
{"ResolveComponentAlias", (PyCFunction)CmpObj_ResolveComponentAlias, 1,
"() -> (Component _rv)"},
PyDoc_STR("() -> (Component _rv)")},
{"GetComponentPublicIndString", (PyCFunction)CmpObj_GetComponentPublicIndString, 1,
"(Str255 theString, short strListID, short index) -> None"},
PyDoc_STR("(Str255 theString, short strListID, short index) -> None")},
{"GetComponentRefcon", (PyCFunction)CmpObj_GetComponentRefcon, 1,
"() -> (long _rv)"},
PyDoc_STR("() -> (long _rv)")},
{"SetComponentRefcon", (PyCFunction)CmpObj_SetComponentRefcon, 1,
"(long theRefcon) -> None"},
PyDoc_STR("(long theRefcon) -> None")},
{"OpenComponentResFile", (PyCFunction)CmpObj_OpenComponentResFile, 1,
"() -> (short _rv)"},
PyDoc_STR("() -> (short _rv)")},
{"GetComponentResource", (PyCFunction)CmpObj_GetComponentResource, 1,
"(OSType resType, short resID) -> (Handle theResource)"},
PyDoc_STR("(OSType resType, short resID) -> (Handle theResource)")},
{"GetComponentIndString", (PyCFunction)CmpObj_GetComponentIndString, 1,
"(Str255 theString, short strListID, short index) -> None"},
PyDoc_STR("(Str255 theString, short strListID, short index) -> None")},
{"CountComponentInstances", (PyCFunction)CmpObj_CountComponentInstances, 1,
"() -> (long _rv)"},
PyDoc_STR("() -> (long _rv)")},
{"SetDefaultComponent", (PyCFunction)CmpObj_SetDefaultComponent, 1,
"(short flags) -> None"},
PyDoc_STR("(short flags) -> None")},
{"CaptureComponent", (PyCFunction)CmpObj_CaptureComponent, 1,
"(Component capturingComponent) -> (Component _rv)"},
PyDoc_STR("(Component capturingComponent) -> (Component _rv)")},
{"UncaptureComponent", (PyCFunction)CmpObj_UncaptureComponent, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"GetComponentIconSuite", (PyCFunction)CmpObj_GetComponentIconSuite, 1,
"() -> (Handle iconSuite)"},
PyDoc_STR("() -> (Handle iconSuite)")},
{NULL, NULL, 0}
};
@ -870,19 +870,19 @@ static PyObject *Cm_RegisterComponentResourceFile(PyObject *_self, PyObject *_ar
static PyMethodDef Cm_methods[] = {
{"RegisterComponentResource", (PyCFunction)Cm_RegisterComponentResource, 1,
"(ComponentResourceHandle cr, short global) -> (Component _rv)"},
PyDoc_STR("(ComponentResourceHandle cr, short global) -> (Component _rv)")},
{"FindNextComponent", (PyCFunction)Cm_FindNextComponent, 1,
"(Component aComponent, ComponentDescription looking) -> (Component _rv)"},
PyDoc_STR("(Component aComponent, ComponentDescription looking) -> (Component _rv)")},
{"CountComponents", (PyCFunction)Cm_CountComponents, 1,
"(ComponentDescription looking) -> (long _rv)"},
PyDoc_STR("(ComponentDescription looking) -> (long _rv)")},
{"GetComponentListModSeed", (PyCFunction)Cm_GetComponentListModSeed, 1,
"() -> (long _rv)"},
PyDoc_STR("() -> (long _rv)")},
{"CloseComponentResFile", (PyCFunction)Cm_CloseComponentResFile, 1,
"(short refnum) -> None"},
PyDoc_STR("(short refnum) -> None")},
{"OpenDefaultComponent", (PyCFunction)Cm_OpenDefaultComponent, 1,
"(OSType componentType, OSType componentSubType) -> (ComponentInstance _rv)"},
PyDoc_STR("(OSType componentType, OSType componentSubType) -> (ComponentInstance _rv)")},
{"RegisterComponentResourceFile", (PyCFunction)Cm_RegisterComponentResourceFile, 1,
"(short resRefNum, short global) -> (long _rv)"},
PyDoc_STR("(short resRefNum, short global) -> (long _rv)")},
{NULL, NULL, 0}
};

452
Mac/Modules/ctl/_Ctlmodule.c
View File

File diff suppressed because it is too large Load Diff

114
Mac/Modules/dlg/_Dlgmodule.c
View File

@ -882,85 +882,85 @@ static PyObject *DlgObj_GetDialogPort(DialogObject *_self, PyObject *_args)
static PyMethodDef DlgObj_methods[] = {
{"DrawDialog", (PyCFunction)DlgObj_DrawDialog, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"UpdateDialog", (PyCFunction)DlgObj_UpdateDialog, 1,
"(RgnHandle updateRgn) -> None"},
PyDoc_STR("(RgnHandle updateRgn) -> None")},
{"HideDialogItem", (PyCFunction)DlgObj_HideDialogItem, 1,
"(DialogItemIndex itemNo) -> None"},
PyDoc_STR("(DialogItemIndex itemNo) -> None")},
{"ShowDialogItem", (PyCFunction)DlgObj_ShowDialogItem, 1,
"(DialogItemIndex itemNo) -> None"},
PyDoc_STR("(DialogItemIndex itemNo) -> None")},
{"FindDialogItem", (PyCFunction)DlgObj_FindDialogItem, 1,
"(Point thePt) -> (DialogItemIndexZeroBased _rv)"},
PyDoc_STR("(Point thePt) -> (DialogItemIndexZeroBased _rv)")},
{"DialogCut", (PyCFunction)DlgObj_DialogCut, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"DialogPaste", (PyCFunction)DlgObj_DialogPaste, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"DialogCopy", (PyCFunction)DlgObj_DialogCopy, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"DialogDelete", (PyCFunction)DlgObj_DialogDelete, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"GetDialogItem", (PyCFunction)DlgObj_GetDialogItem, 1,
"(DialogItemIndex itemNo) -> (DialogItemType itemType, Handle item, Rect box)"},
PyDoc_STR("(DialogItemIndex itemNo) -> (DialogItemType itemType, Handle item, Rect box)")},
{"SetDialogItem", (PyCFunction)DlgObj_SetDialogItem, 1,
"(DialogItemIndex itemNo, DialogItemType itemType, Handle item, Rect box) -> None"},
PyDoc_STR("(DialogItemIndex itemNo, DialogItemType itemType, Handle item, Rect box) -> None")},
{"SelectDialogItemText", (PyCFunction)DlgObj_SelectDialogItemText, 1,
"(DialogItemIndex itemNo, SInt16 strtSel, SInt16 endSel) -> None"},
PyDoc_STR("(DialogItemIndex itemNo, SInt16 strtSel, SInt16 endSel) -> None")},
{"AppendDITL", (PyCFunction)DlgObj_AppendDITL, 1,
"(Handle theHandle, DITLMethod method) -> None"},
PyDoc_STR("(Handle theHandle, DITLMethod method) -> None")},
{"CountDITL", (PyCFunction)DlgObj_CountDITL, 1,
"() -> (DialogItemIndex _rv)"},
PyDoc_STR("() -> (DialogItemIndex _rv)")},
{"ShortenDITL", (PyCFunction)DlgObj_ShortenDITL, 1,
"(DialogItemIndex numberItems) -> None"},
PyDoc_STR("(DialogItemIndex numberItems) -> None")},
#if TARGET_API_MAC_CARBON
{"InsertDialogItem", (PyCFunction)DlgObj_InsertDialogItem, 1,
"(DialogItemIndex afterItem, DialogItemType itemType, Handle itemHandle, Rect box) -> None"},
PyDoc_STR("(DialogItemIndex afterItem, DialogItemType itemType, Handle itemHandle, Rect box) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"RemoveDialogItems", (PyCFunction)DlgObj_RemoveDialogItems, 1,
"(DialogItemIndex itemNo, DialogItemIndex amountToRemove, Boolean disposeItemData) -> None"},
PyDoc_STR("(DialogItemIndex itemNo, DialogItemIndex amountToRemove, Boolean disposeItemData) -> None")},
#endif
{"StdFilterProc", (PyCFunction)DlgObj_StdFilterProc, 1,
"() -> (Boolean _rv, EventRecord event, DialogItemIndex itemHit)"},
PyDoc_STR("() -> (Boolean _rv, EventRecord event, DialogItemIndex itemHit)")},
{"SetDialogDefaultItem", (PyCFunction)DlgObj_SetDialogDefaultItem, 1,
"(DialogItemIndex newItem) -> None"},
PyDoc_STR("(DialogItemIndex newItem) -> None")},
{"SetDialogCancelItem", (PyCFunction)DlgObj_SetDialogCancelItem, 1,
"(DialogItemIndex newItem) -> None"},
PyDoc_STR("(DialogItemIndex newItem) -> None")},
{"SetDialogTracksCursor", (PyCFunction)DlgObj_SetDialogTracksCursor, 1,
"(Boolean tracks) -> None"},
PyDoc_STR("(Boolean tracks) -> None")},
{"AutoSizeDialog", (PyCFunction)DlgObj_AutoSizeDialog, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"GetDialogItemAsControl", (PyCFunction)DlgObj_GetDialogItemAsControl, 1,
"(SInt16 inItemNo) -> (ControlHandle outControl)"},
PyDoc_STR("(SInt16 inItemNo) -> (ControlHandle outControl)")},
{"MoveDialogItem", (PyCFunction)DlgObj_MoveDialogItem, 1,
"(SInt16 inItemNo, SInt16 inHoriz, SInt16 inVert) -> None"},
PyDoc_STR("(SInt16 inItemNo, SInt16 inHoriz, SInt16 inVert) -> None")},
{"SizeDialogItem", (PyCFunction)DlgObj_SizeDialogItem, 1,
"(SInt16 inItemNo, SInt16 inWidth, SInt16 inHeight) -> None"},
PyDoc_STR("(SInt16 inItemNo, SInt16 inWidth, SInt16 inHeight) -> None")},
{"AppendDialogItemList", (PyCFunction)DlgObj_AppendDialogItemList, 1,
"(SInt16 ditlID, DITLMethod method) -> None"},
PyDoc_STR("(SInt16 ditlID, DITLMethod method) -> None")},
{"SetDialogTimeout", (PyCFunction)DlgObj_SetDialogTimeout, 1,
"(SInt16 inButtonToPress, UInt32 inSecondsToWait) -> None"},
PyDoc_STR("(SInt16 inButtonToPress, UInt32 inSecondsToWait) -> None")},
{"GetDialogTimeout", (PyCFunction)DlgObj_GetDialogTimeout, 1,
"() -> (SInt16 outButtonToPress, UInt32 outSecondsToWait, UInt32 outSecondsRemaining)"},
PyDoc_STR("() -> (SInt16 outButtonToPress, UInt32 outSecondsToWait, UInt32 outSecondsRemaining)")},
{"SetModalDialogEventMask", (PyCFunction)DlgObj_SetModalDialogEventMask, 1,
"(EventMask inMask) -> None"},
PyDoc_STR("(EventMask inMask) -> None")},
{"GetModalDialogEventMask", (PyCFunction)DlgObj_GetModalDialogEventMask, 1,
"() -> (EventMask outMask)"},
PyDoc_STR("() -> (EventMask outMask)")},
{"GetDialogWindow", (PyCFunction)DlgObj_GetDialogWindow, 1,
"() -> (WindowPtr _rv)"},
PyDoc_STR("() -> (WindowPtr _rv)")},
{"GetDialogTextEditHandle", (PyCFunction)DlgObj_GetDialogTextEditHandle, 1,
"() -> (TEHandle _rv)"},
PyDoc_STR("() -> (TEHandle _rv)")},
{"GetDialogDefaultItem", (PyCFunction)DlgObj_GetDialogDefaultItem, 1,
"() -> (SInt16 _rv)"},
PyDoc_STR("() -> (SInt16 _rv)")},
{"GetDialogCancelItem", (PyCFunction)DlgObj_GetDialogCancelItem, 1,
"() -> (SInt16 _rv)"},
PyDoc_STR("() -> (SInt16 _rv)")},
{"GetDialogKeyboardFocusItem", (PyCFunction)DlgObj_GetDialogKeyboardFocusItem, 1,
"() -> (SInt16 _rv)"},
PyDoc_STR("() -> (SInt16 _rv)")},
{"SetPortDialogPort", (PyCFunction)DlgObj_SetPortDialogPort, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"GetDialogPort", (PyCFunction)DlgObj_GetDialogPort, 1,
"() -> (CGrafPtr _rv)"},
PyDoc_STR("() -> (CGrafPtr _rv)")},
{NULL, NULL, 0}
};
@ -1471,48 +1471,48 @@ static PyObject *Dlg_SetUserItemHandler(PyObject *_self, PyObject *_args)
static PyMethodDef Dlg_methods[] = {
{"NewDialog", (PyCFunction)Dlg_NewDialog, 1,
"(Rect boundsRect, Str255 title, Boolean visible, SInt16 procID, WindowPtr behind, Boolean goAwayFlag, SInt32 refCon, Handle items) -> (DialogPtr _rv)"},
PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, SInt16 procID, WindowPtr behind, Boolean goAwayFlag, SInt32 refCon, Handle items) -> (DialogPtr _rv)")},
{"GetNewDialog", (PyCFunction)Dlg_GetNewDialog, 1,
"(SInt16 dialogID, WindowPtr behind) -> (DialogPtr _rv)"},
PyDoc_STR("(SInt16 dialogID, WindowPtr behind) -> (DialogPtr _rv)")},
{"NewColorDialog", (PyCFunction)Dlg_NewColorDialog, 1,
"(Rect boundsRect, Str255 title, Boolean visible, SInt16 procID, WindowPtr behind, Boolean goAwayFlag, SInt32 refCon, Handle items) -> (DialogPtr _rv)"},
PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, SInt16 procID, WindowPtr behind, Boolean goAwayFlag, SInt32 refCon, Handle items) -> (DialogPtr _rv)")},
{"ModalDialog", (PyCFunction)Dlg_ModalDialog, 1,
"(PyObject* modalFilter) -> (DialogItemIndex itemHit)"},
PyDoc_STR("(PyObject* modalFilter) -> (DialogItemIndex itemHit)")},
{"IsDialogEvent", (PyCFunction)Dlg_IsDialogEvent, 1,
"(EventRecord theEvent) -> (Boolean _rv)"},
PyDoc_STR("(EventRecord theEvent) -> (Boolean _rv)")},
{"DialogSelect", (PyCFunction)Dlg_DialogSelect, 1,
"(EventRecord theEvent) -> (Boolean _rv, DialogPtr theDialog, DialogItemIndex itemHit)"},
PyDoc_STR("(EventRecord theEvent) -> (Boolean _rv, DialogPtr theDialog, DialogItemIndex itemHit)")},
{"Alert", (PyCFunction)Dlg_Alert, 1,
"(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"},
PyDoc_STR("(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)")},
{"StopAlert", (PyCFunction)Dlg_StopAlert, 1,
"(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"},
PyDoc_STR("(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)")},
{"NoteAlert", (PyCFunction)Dlg_NoteAlert, 1,
"(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"},
PyDoc_STR("(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)")},
{"CautionAlert", (PyCFunction)Dlg_CautionAlert, 1,
"(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)"},
PyDoc_STR("(SInt16 alertID, PyObject* modalFilter) -> (DialogItemIndex _rv)")},
{"ParamText", (PyCFunction)Dlg_ParamText, 1,
"(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None"},
PyDoc_STR("(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None")},
{"GetDialogItemText", (PyCFunction)Dlg_GetDialogItemText, 1,
"(Handle item) -> (Str255 text)"},
PyDoc_STR("(Handle item) -> (Str255 text)")},
{"SetDialogItemText", (PyCFunction)Dlg_SetDialogItemText, 1,
"(Handle item, Str255 text) -> None"},
PyDoc_STR("(Handle item, Str255 text) -> None")},
{"GetAlertStage", (PyCFunction)Dlg_GetAlertStage, 1,
"() -> (SInt16 _rv)"},
PyDoc_STR("() -> (SInt16 _rv)")},
{"SetDialogFont", (PyCFunction)Dlg_SetDialogFont, 1,
"(SInt16 fontNum) -> None"},
PyDoc_STR("(SInt16 fontNum) -> None")},
{"ResetAlertStage", (PyCFunction)Dlg_ResetAlertStage, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#if TARGET_API_MAC_CARBON
{"GetParamText", (PyCFunction)Dlg_GetParamText, 1,
"(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None"},
PyDoc_STR("(Str255 param0, Str255 param1, Str255 param2, Str255 param3) -> None")},
#endif
{"NewFeaturesDialog", (PyCFunction)Dlg_NewFeaturesDialog, 1,
"(Rect inBoundsRect, Str255 inTitle, Boolean inIsVisible, SInt16 inProcID, WindowPtr inBehind, Boolean inGoAwayFlag, SInt32 inRefCon, Handle inItemListHandle, UInt32 inFlags) -> (DialogPtr _rv)"},
PyDoc_STR("(Rect inBoundsRect, Str255 inTitle, Boolean inIsVisible, SInt16 inProcID, WindowPtr inBehind, Boolean inGoAwayFlag, SInt32 inRefCon, Handle inItemListHandle, UInt32 inFlags) -> (DialogPtr _rv)")},
{"GetDialogFromWindow", (PyCFunction)Dlg_GetDialogFromWindow, 1,
"(WindowPtr window) -> (DialogPtr _rv)"},
PyDoc_STR("(WindowPtr window) -> (DialogPtr _rv)")},
{"SetUserItemHandler", (PyCFunction)Dlg_SetUserItemHandler, 1,
NULL},
PyDoc_STR(NULL)},
{NULL, NULL, 0}
};

72
Mac/Modules/drag/_Dragmodule.c
View File

@ -684,59 +684,59 @@ static PyObject *DragObj_UpdateDragHilite(DragObjObject *_self, PyObject *_args)
static PyMethodDef DragObj_methods[] = {
{"DisposeDrag", (PyCFunction)DragObj_DisposeDrag, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"AddDragItemFlavor", (PyCFunction)DragObj_AddDragItemFlavor, 1,
"(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, FlavorFlags theFlags) -> None"},
PyDoc_STR("(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, FlavorFlags theFlags) -> None")},
{"SetDragItemFlavorData", (PyCFunction)DragObj_SetDragItemFlavorData, 1,
"(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, UInt32 dataOffset) -> None"},
PyDoc_STR("(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, UInt32 dataOffset) -> None")},
{"SetDragImage", (PyCFunction)DragObj_SetDragImage, 1,
"(PixMapHandle imagePixMap, RgnHandle imageRgn, Point imageOffsetPt, DragImageFlags theImageFlags) -> None"},
PyDoc_STR("(PixMapHandle imagePixMap, RgnHandle imageRgn, Point imageOffsetPt, DragImageFlags theImageFlags) -> None")},
{"ChangeDragBehaviors", (PyCFunction)DragObj_ChangeDragBehaviors, 1,
"(DragBehaviors inBehaviorsToSet, DragBehaviors inBehaviorsToClear) -> None"},
PyDoc_STR("(DragBehaviors inBehaviorsToSet, DragBehaviors inBehaviorsToClear) -> None")},
{"TrackDrag", (PyCFunction)DragObj_TrackDrag, 1,
"(EventRecord theEvent, RgnHandle theRegion) -> None"},
PyDoc_STR("(EventRecord theEvent, RgnHandle theRegion) -> None")},
{"CountDragItems", (PyCFunction)DragObj_CountDragItems, 1,
"() -> (UInt16 numItems)"},
PyDoc_STR("() -> (UInt16 numItems)")},
{"GetDragItemReferenceNumber", (PyCFunction)DragObj_GetDragItemReferenceNumber, 1,
"(UInt16 index) -> (ItemReference theItemRef)"},
PyDoc_STR("(UInt16 index) -> (ItemReference theItemRef)")},
{"CountDragItemFlavors", (PyCFunction)DragObj_CountDragItemFlavors, 1,
"(ItemReference theItemRef) -> (UInt16 numFlavors)"},
PyDoc_STR("(ItemReference theItemRef) -> (UInt16 numFlavors)")},
{"GetFlavorType", (PyCFunction)DragObj_GetFlavorType, 1,
"(ItemReference theItemRef, UInt16 index) -> (FlavorType theType)"},
PyDoc_STR("(ItemReference theItemRef, UInt16 index) -> (FlavorType theType)")},
{"GetFlavorFlags", (PyCFunction)DragObj_GetFlavorFlags, 1,
"(ItemReference theItemRef, FlavorType theType) -> (FlavorFlags theFlags)"},
PyDoc_STR("(ItemReference theItemRef, FlavorType theType) -> (FlavorFlags theFlags)")},
{"GetFlavorDataSize", (PyCFunction)DragObj_GetFlavorDataSize, 1,
"(ItemReference theItemRef, FlavorType theType) -> (Size dataSize)"},
PyDoc_STR("(ItemReference theItemRef, FlavorType theType) -> (Size dataSize)")},
{"GetFlavorData", (PyCFunction)DragObj_GetFlavorData, 1,
"(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, UInt32 dataOffset) -> (Buffer dataPtr)"},
PyDoc_STR("(ItemReference theItemRef, FlavorType theType, Buffer dataPtr, UInt32 dataOffset) -> (Buffer dataPtr)")},
{"GetDragItemBounds", (PyCFunction)DragObj_GetDragItemBounds, 1,
"(ItemReference theItemRef) -> (Rect itemBounds)"},
PyDoc_STR("(ItemReference theItemRef) -> (Rect itemBounds)")},
{"SetDragItemBounds", (PyCFunction)DragObj_SetDragItemBounds, 1,
"(ItemReference theItemRef, Rect itemBounds) -> None"},
PyDoc_STR("(ItemReference theItemRef, Rect itemBounds) -> None")},
{"GetDropLocation", (PyCFunction)DragObj_GetDropLocation, 1,
"() -> (AEDesc dropLocation)"},
PyDoc_STR("() -> (AEDesc dropLocation)")},
{"SetDropLocation", (PyCFunction)DragObj_SetDropLocation, 1,
"(AEDesc dropLocation) -> None"},
PyDoc_STR("(AEDesc dropLocation) -> None")},
{"GetDragAttributes", (PyCFunction)DragObj_GetDragAttributes, 1,
"() -> (DragAttributes flags)"},
PyDoc_STR("() -> (DragAttributes flags)")},
{"GetDragMouse", (PyCFunction)DragObj_GetDragMouse, 1,
"() -> (Point mouse, Point globalPinnedMouse)"},
PyDoc_STR("() -> (Point mouse, Point globalPinnedMouse)")},
{"SetDragMouse", (PyCFunction)DragObj_SetDragMouse, 1,
"(Point globalPinnedMouse) -> None"},
PyDoc_STR("(Point globalPinnedMouse) -> None")},
{"GetDragOrigin", (PyCFunction)DragObj_GetDragOrigin, 1,
"() -> (Point globalInitialMouse)"},
PyDoc_STR("() -> (Point globalInitialMouse)")},
{"GetDragModifiers", (PyCFunction)DragObj_GetDragModifiers, 1,
"() -> (SInt16 modifiers, SInt16 mouseDownModifiers, SInt16 mouseUpModifiers)"},
PyDoc_STR("() -> (SInt16 modifiers, SInt16 mouseDownModifiers, SInt16 mouseUpModifiers)")},
{"ShowDragHilite", (PyCFunction)DragObj_ShowDragHilite, 1,
"(RgnHandle hiliteFrame, Boolean inside) -> None"},
PyDoc_STR("(RgnHandle hiliteFrame, Boolean inside) -> None")},
{"HideDragHilite", (PyCFunction)DragObj_HideDragHilite, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"DragPreScroll", (PyCFunction)DragObj_DragPreScroll, 1,
"(SInt16 dH, SInt16 dV) -> None"},
PyDoc_STR("(SInt16 dH, SInt16 dV) -> None")},
{"DragPostScroll", (PyCFunction)DragObj_DragPostScroll, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"UpdateDragHilite", (PyCFunction)DragObj_UpdateDragHilite, 1,
"(RgnHandle updateRgn) -> None"},
PyDoc_STR("(RgnHandle updateRgn) -> None")},
{NULL, NULL, 0}
};
@ -959,23 +959,23 @@ static PyObject *Drag_RemoveReceiveHandler(PyObject *_self, PyObject *_args)
static PyMethodDef Drag_methods[] = {
{"NewDrag", (PyCFunction)Drag_NewDrag, 1,
"() -> (DragRef theDrag)"},
PyDoc_STR("() -> (DragRef theDrag)")},
{"GetDragHiliteColor", (PyCFunction)Drag_GetDragHiliteColor, 1,
"(WindowPtr window) -> (RGBColor color)"},
PyDoc_STR("(WindowPtr window) -> (RGBColor color)")},
{"WaitMouseMoved", (PyCFunction)Drag_WaitMouseMoved, 1,
"(Point initialMouse) -> (Boolean _rv)"},
PyDoc_STR("(Point initialMouse) -> (Boolean _rv)")},
{"ZoomRects", (PyCFunction)Drag_ZoomRects, 1,
"(Rect fromRect, Rect toRect, SInt16 zoomSteps, ZoomAcceleration acceleration) -> None"},
PyDoc_STR("(Rect fromRect, Rect toRect, SInt16 zoomSteps, ZoomAcceleration acceleration) -> None")},
{"ZoomRegion", (PyCFunction)Drag_ZoomRegion, 1,
"(RgnHandle region, Point zoomDistance, SInt16 zoomSteps, ZoomAcceleration acceleration) -> None"},
PyDoc_STR("(RgnHandle region, Point zoomDistance, SInt16 zoomSteps, ZoomAcceleration acceleration) -> None")},
{"InstallTrackingHandler", (PyCFunction)Drag_InstallTrackingHandler, 1,
NULL},
PyDoc_STR(NULL)},
{"InstallReceiveHandler", (PyCFunction)Drag_InstallReceiveHandler, 1,
NULL},
PyDoc_STR(NULL)},
{"RemoveTrackingHandler", (PyCFunction)Drag_RemoveTrackingHandler, 1,
NULL},
PyDoc_STR(NULL)},
{"RemoveReceiveHandler", (PyCFunction)Drag_RemoveReceiveHandler, 1,
NULL},
PyDoc_STR(NULL)},
{NULL, NULL, 0}
};

64
Mac/Modules/evt/_Evtmodule.c
View File

@ -592,93 +592,93 @@ static PyObject *Evt_WaitNextEvent(PyObject *_self, PyObject *_args)
static PyMethodDef Evt_methods[] = {
{"GetMouse", (PyCFunction)Evt_GetMouse, 1,
"() -> (Point mouseLoc)"},
PyDoc_STR("() -> (Point mouseLoc)")},
{"Button", (PyCFunction)Evt_Button, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
{"StillDown", (PyCFunction)Evt_StillDown, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
{"WaitMouseUp", (PyCFunction)Evt_WaitMouseUp, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
{"GetCaretTime", (PyCFunction)Evt_GetCaretTime, 1,
"() -> (UInt32 _rv)"},
PyDoc_STR("() -> (UInt32 _rv)")},
{"GetKeys", (PyCFunction)Evt_GetKeys, 1,
"() -> (KeyMap theKeys)"},
PyDoc_STR("() -> (KeyMap theKeys)")},
{"GetDblTime", (PyCFunction)Evt_GetDblTime, 1,
"() -> (UInt32 _rv)"},
PyDoc_STR("() -> (UInt32 _rv)")},
{"SetEventMask", (PyCFunction)Evt_SetEventMask, 1,
"(EventMask value) -> None"},
PyDoc_STR("(EventMask value) -> None")},
{"GetNextEvent", (PyCFunction)Evt_GetNextEvent, 1,
"(EventMask eventMask) -> (Boolean _rv, EventRecord theEvent)"},
PyDoc_STR("(EventMask eventMask) -> (Boolean _rv, EventRecord theEvent)")},
{"EventAvail", (PyCFunction)Evt_EventAvail, 1,
"(EventMask eventMask) -> (Boolean _rv, EventRecord theEvent)"},
PyDoc_STR("(EventMask eventMask) -> (Boolean _rv, EventRecord theEvent)")},
{"PostEvent", (PyCFunction)Evt_PostEvent, 1,
"(EventKind eventNum, UInt32 eventMsg) -> None"},
PyDoc_STR("(EventKind eventNum, UInt32 eventMsg) -> None")},
#if !TARGET_API_MAC_CARBON
{"OSEventAvail", (PyCFunction)Evt_OSEventAvail, 1,
"(EventMask mask) -> (Boolean _rv, EventRecord theEvent)"},
PyDoc_STR("(EventMask mask) -> (Boolean _rv, EventRecord theEvent)")},
#endif
#if !TARGET_API_MAC_CARBON
{"GetOSEvent", (PyCFunction)Evt_GetOSEvent, 1,
"(EventMask mask) -> (Boolean _rv, EventRecord theEvent)"},
PyDoc_STR("(EventMask mask) -> (Boolean _rv, EventRecord theEvent)")},
#endif
{"FlushEvents", (PyCFunction)Evt_FlushEvents, 1,
"(EventMask whichMask, EventMask stopMask) -> None"},
PyDoc_STR("(EventMask whichMask, EventMask stopMask) -> None")},
#if !TARGET_API_MAC_CARBON
{"SystemClick", (PyCFunction)Evt_SystemClick, 1,
"(EventRecord theEvent, WindowPtr theWindow) -> None"},
PyDoc_STR("(EventRecord theEvent, WindowPtr theWindow) -> None")},
#endif
#if !TARGET_API_MAC_CARBON
{"SystemTask", (PyCFunction)Evt_SystemTask, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
#if !TARGET_API_MAC_CARBON
{"SystemEvent", (PyCFunction)Evt_SystemEvent, 1,
"(EventRecord theEvent) -> (Boolean _rv)"},
PyDoc_STR("(EventRecord theEvent) -> (Boolean _rv)")},
#endif
#if TARGET_API_MAC_CARBON
{"GetGlobalMouse", (PyCFunction)Evt_GetGlobalMouse, 1,
"() -> (Point globalMouse)"},
PyDoc_STR("() -> (Point globalMouse)")},
#endif
#if TARGET_API_MAC_CARBON
{"GetCurrentKeyModifiers", (PyCFunction)Evt_GetCurrentKeyModifiers, 1,
"() -> (UInt32 _rv)"},
PyDoc_STR("() -> (UInt32 _rv)")},
#endif
#if TARGET_API_MAC_CARBON
{"CheckEventQueueForUserCancel", (PyCFunction)Evt_CheckEventQueueForUserCancel, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
#endif
{"KeyScript", (PyCFunction)Evt_KeyScript, 1,
"(short code) -> None"},
PyDoc_STR("(short code) -> None")},
{"IsCmdChar", (PyCFunction)Evt_IsCmdChar, 1,
"(EventRecord event, short test) -> (Boolean _rv)"},
PyDoc_STR("(EventRecord event, short test) -> (Boolean _rv)")},
{"LMGetKeyThresh", (PyCFunction)Evt_LMGetKeyThresh, 1,
"() -> (SInt16 _rv)"},
PyDoc_STR("() -> (SInt16 _rv)")},
{"LMSetKeyThresh", (PyCFunction)Evt_LMSetKeyThresh, 1,
"(SInt16 value) -> None"},
PyDoc_STR("(SInt16 value) -> None")},
{"LMGetKeyRepThresh", (PyCFunction)Evt_LMGetKeyRepThresh, 1,
"() -> (SInt16 _rv)"},
PyDoc_STR("() -> (SInt16 _rv)")},
{"LMSetKeyRepThresh", (PyCFunction)Evt_LMSetKeyRepThresh, 1,
"(SInt16 value) -> None"},
PyDoc_STR("(SInt16 value) -> None")},
{"LMGetKbdLast", (PyCFunction)Evt_LMGetKbdLast, 1,
"() -> (UInt8 _rv)"},
PyDoc_STR("() -> (UInt8 _rv)")},
{"LMSetKbdLast", (PyCFunction)Evt_LMSetKbdLast, 1,
"(UInt8 value) -> None"},
PyDoc_STR("(UInt8 value) -> None")},
{"LMGetKbdType", (PyCFunction)Evt_LMGetKbdType, 1,
"() -> (UInt8 _rv)"},
PyDoc_STR("() -> (UInt8 _rv)")},
{"LMSetKbdType", (PyCFunction)Evt_LMSetKbdType, 1,
"(UInt8 value) -> None"},
PyDoc_STR("(UInt8 value) -> None")},
{"TickCount", (PyCFunction)Evt_TickCount, 1,
"() -> (UInt32 _rv)"},
PyDoc_STR("() -> (UInt32 _rv)")},
{"WaitNextEvent", (PyCFunction)Evt_WaitNextEvent, 1,
"(EventMask eventMask, UInt32 sleep [,RegionHandle]) -> (Boolean _rv, EventRecord theEvent)"},
PyDoc_STR("(EventMask eventMask, UInt32 sleep [,RegionHandle]) -> (Boolean _rv, EventRecord theEvent)")},
{NULL, NULL, 0}
};

36
Mac/Modules/fm/_Fmmodule.c
View File

@ -369,48 +369,48 @@ static PyMethodDef Fm_methods[] = {
#if !TARGET_API_MAC_CARBON
{"InitFonts", (PyCFunction)Fm_InitFonts, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
{"GetFontName", (PyCFunction)Fm_GetFontName, 1,
"(short familyID) -> (Str255 name)"},
PyDoc_STR("(short familyID) -> (Str255 name)")},
{"GetFNum", (PyCFunction)Fm_GetFNum, 1,
"(Str255 name) -> (short familyID)"},
PyDoc_STR("(Str255 name) -> (short familyID)")},
{"RealFont", (PyCFunction)Fm_RealFont, 1,
"(short fontNum, short size) -> (Boolean _rv)"},
PyDoc_STR("(short fontNum, short size) -> (Boolean _rv)")},
#if !TARGET_API_MAC_CARBON
{"SetFontLock", (PyCFunction)Fm_SetFontLock, 1,
"(Boolean lockFlag) -> None"},
PyDoc_STR("(Boolean lockFlag) -> None")},
#endif
{"SetFScaleDisable", (PyCFunction)Fm_SetFScaleDisable, 1,
"(Boolean fscaleDisable) -> None"},
PyDoc_STR("(Boolean fscaleDisable) -> None")},
{"FontMetrics", (PyCFunction)Fm_FontMetrics, 1,
"() -> (FMetricRec theMetrics)"},
PyDoc_STR("() -> (FMetricRec theMetrics)")},
{"SetFractEnable", (PyCFunction)Fm_SetFractEnable, 1,
"(Boolean fractEnable) -> None"},
PyDoc_STR("(Boolean fractEnable) -> None")},
{"GetDefFontSize", (PyCFunction)Fm_GetDefFontSize, 1,
"() -> (short _rv)"},
PyDoc_STR("() -> (short _rv)")},
{"IsOutline", (PyCFunction)Fm_IsOutline, 1,
"(Point numer, Point denom) -> (Boolean _rv)"},
PyDoc_STR("(Point numer, Point denom) -> (Boolean _rv)")},
{"SetOutlinePreferred", (PyCFunction)Fm_SetOutlinePreferred, 1,
"(Boolean outlinePreferred) -> None"},
PyDoc_STR("(Boolean outlinePreferred) -> None")},
{"GetOutlinePreferred", (PyCFunction)Fm_GetOutlinePreferred, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
{"SetPreserveGlyph", (PyCFunction)Fm_SetPreserveGlyph, 1,
"(Boolean preserveGlyph) -> None"},
PyDoc_STR("(Boolean preserveGlyph) -> None")},
{"GetPreserveGlyph", (PyCFunction)Fm_GetPreserveGlyph, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
#if !TARGET_API_MAC_CARBON
{"FlushFonts", (PyCFunction)Fm_FlushFonts, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
{"GetSysFont", (PyCFunction)Fm_GetSysFont, 1,
"() -> (short _rv)"},
PyDoc_STR("() -> (short _rv)")},
{"GetAppFont", (PyCFunction)Fm_GetAppFont, 1,
"() -> (short _rv)"},
PyDoc_STR("() -> (short _rv)")},
{"QDTextBounds", (PyCFunction)Fm_QDTextBounds, 1,
"(Buffer inText) -> (Rect bounds)"},
PyDoc_STR("(Buffer inText) -> (Rect bounds)")},
{NULL, NULL, 0}
};

30
Mac/Modules/help/_Helpmodule.c
View File

@ -249,35 +249,35 @@ static PyObject *Help_HMGetBalloonWindow(PyObject *_self, PyObject *_args)
static PyMethodDef Help_methods[] = {
{"HMGetHelpMenuHandle", (PyCFunction)Help_HMGetHelpMenuHandle, 1,
"() -> (MenuRef mh)"},
PyDoc_STR("() -> (MenuRef mh)")},
{"HMRemoveBalloon", (PyCFunction)Help_HMRemoveBalloon, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"HMIsBalloon", (PyCFunction)Help_HMIsBalloon, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
{"HMGetBalloons", (PyCFunction)Help_HMGetBalloons, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
{"HMSetBalloons", (PyCFunction)Help_HMSetBalloons, 1,
"(Boolean flag) -> None"},
PyDoc_STR("(Boolean flag) -> None")},
{"HMSetFont", (PyCFunction)Help_HMSetFont, 1,
"(SInt16 font) -> None"},
PyDoc_STR("(SInt16 font) -> None")},
{"HMSetFontSize", (PyCFunction)Help_HMSetFontSize, 1,
"(UInt16 fontSize) -> None"},
PyDoc_STR("(UInt16 fontSize) -> None")},
{"HMGetFont", (PyCFunction)Help_HMGetFont, 1,
"() -> (SInt16 font)"},
PyDoc_STR("() -> (SInt16 font)")},
{"HMGetFontSize", (PyCFunction)Help_HMGetFontSize, 1,
"() -> (UInt16 fontSize)"},
PyDoc_STR("() -> (UInt16 fontSize)")},
{"HMSetDialogResID", (PyCFunction)Help_HMSetDialogResID, 1,
"(SInt16 resID) -> None"},
PyDoc_STR("(SInt16 resID) -> None")},
{"HMSetMenuResID", (PyCFunction)Help_HMSetMenuResID, 1,
"(SInt16 menuID, SInt16 resID) -> None"},
PyDoc_STR("(SInt16 menuID, SInt16 resID) -> None")},
{"HMScanTemplateItems", (PyCFunction)Help_HMScanTemplateItems, 1,
"(SInt16 whichID, SInt16 whichResFile, ResType whichType) -> None"},
PyDoc_STR("(SInt16 whichID, SInt16 whichResFile, ResType whichType) -> None")},
{"HMGetDialogResID", (PyCFunction)Help_HMGetDialogResID, 1,
"() -> (SInt16 resID)"},
PyDoc_STR("() -> (SInt16 resID)")},
{"HMGetMenuResID", (PyCFunction)Help_HMGetMenuResID, 1,
"(SInt16 menuID) -> (SInt16 resID)"},
PyDoc_STR("(SInt16 menuID) -> (SInt16 resID)")},
{"HMGetBalloonWindow", (PyCFunction)Help_HMGetBalloonWindow, 1,
"() -> (WindowPtr window)"},
PyDoc_STR("() -> (WindowPtr window)")},
{NULL, NULL, 0}
};

10
Mac/Modules/ibcarbon/_IBCarbon.c
View File

@ -130,13 +130,13 @@ static PyObject *IBNibRefObj_SetMenuBarFromNib(IBNibRefObject *_self, PyObject *
static PyMethodDef IBNibRefObj_methods[] = {
{"CreateWindowFromNib", (PyCFunction)IBNibRefObj_CreateWindowFromNib, 1,
"(CFStringRef inName) -> (WindowPtr outWindow)"},
PyDoc_STR("(CFStringRef inName) -> (WindowPtr outWindow)")},
{"CreateMenuFromNib", (PyCFunction)IBNibRefObj_CreateMenuFromNib, 1,
"(CFStringRef inName) -> (MenuHandle outMenuRef)"},
PyDoc_STR("(CFStringRef inName) -> (MenuHandle outMenuRef)")},
{"CreateMenuBarFromNib", (PyCFunction)IBNibRefObj_CreateMenuBarFromNib, 1,
"(CFStringRef inName) -> (Handle outMenuBar)"},
PyDoc_STR("(CFStringRef inName) -> (Handle outMenuBar)")},
{"SetMenuBarFromNib", (PyCFunction)IBNibRefObj_SetMenuBarFromNib, 1,
"(CFStringRef inName) -> None"},
PyDoc_STR("(CFStringRef inName) -> None")},
{NULL, NULL, 0}
};
@ -196,7 +196,7 @@ static PyObject *IBCarbon_CreateNibReference(PyObject *_self, PyObject *_args)
static PyMethodDef IBCarbon_methods[] = {
{"CreateNibReference", (PyCFunction)IBCarbon_CreateNibReference, 1,
"(CFStringRef inNibName) -> (IBNibRef outNibRef)"},
PyDoc_STR("(CFStringRef inNibName) -> (IBNibRef outNibRef)")},
{NULL, NULL, 0}
};

122
Mac/Modules/icn/_Icnmodule.c
View File

@ -1442,141 +1442,141 @@ static PyObject *Icn_WriteIconFile(PyObject *_self, PyObject *_args)
static PyMethodDef Icn_methods[] = {
{"GetCIcon", (PyCFunction)Icn_GetCIcon, 1,
"(SInt16 iconID) -> (CIconHandle _rv)"},
PyDoc_STR("(SInt16 iconID) -> (CIconHandle _rv)")},
{"PlotCIcon", (PyCFunction)Icn_PlotCIcon, 1,
"(Rect theRect, CIconHandle theIcon) -> None"},
PyDoc_STR("(Rect theRect, CIconHandle theIcon) -> None")},
{"DisposeCIcon", (PyCFunction)Icn_DisposeCIcon, 1,
"(CIconHandle theIcon) -> None"},
PyDoc_STR("(CIconHandle theIcon) -> None")},
{"GetIcon", (PyCFunction)Icn_GetIcon, 1,
"(SInt16 iconID) -> (Handle _rv)"},
PyDoc_STR("(SInt16 iconID) -> (Handle _rv)")},
{"PlotIcon", (PyCFunction)Icn_PlotIcon, 1,
"(Rect theRect, Handle theIcon) -> None"},
PyDoc_STR("(Rect theRect, Handle theIcon) -> None")},
{"PlotIconID", (PyCFunction)Icn_PlotIconID, 1,
"(Rect theRect, IconAlignmentType align, IconTransformType transform, SInt16 theResID) -> None"},
PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, SInt16 theResID) -> None")},
{"NewIconSuite", (PyCFunction)Icn_NewIconSuite, 1,
"() -> (IconSuiteRef theIconSuite)"},
PyDoc_STR("() -> (IconSuiteRef theIconSuite)")},
{"AddIconToSuite", (PyCFunction)Icn_AddIconToSuite, 1,
"(Handle theIconData, IconSuiteRef theSuite, ResType theType) -> None"},
PyDoc_STR("(Handle theIconData, IconSuiteRef theSuite, ResType theType) -> None")},
{"GetIconFromSuite", (PyCFunction)Icn_GetIconFromSuite, 1,
"(IconSuiteRef theSuite, ResType theType) -> (Handle theIconData)"},
PyDoc_STR("(IconSuiteRef theSuite, ResType theType) -> (Handle theIconData)")},
{"GetIconSuite", (PyCFunction)Icn_GetIconSuite, 1,
"(SInt16 theResID, IconSelectorValue selector) -> (IconSuiteRef theIconSuite)"},
PyDoc_STR("(SInt16 theResID, IconSelectorValue selector) -> (IconSuiteRef theIconSuite)")},
{"DisposeIconSuite", (PyCFunction)Icn_DisposeIconSuite, 1,
"(IconSuiteRef theIconSuite, Boolean disposeData) -> None"},
PyDoc_STR("(IconSuiteRef theIconSuite, Boolean disposeData) -> None")},
{"PlotIconSuite", (PyCFunction)Icn_PlotIconSuite, 1,
"(Rect theRect, IconAlignmentType align, IconTransformType transform, IconSuiteRef theIconSuite) -> None"},
PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, IconSuiteRef theIconSuite) -> None")},
{"LoadIconCache", (PyCFunction)Icn_LoadIconCache, 1,
"(Rect theRect, IconAlignmentType align, IconTransformType transform, IconCacheRef theIconCache) -> None"},
PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, IconCacheRef theIconCache) -> None")},
{"GetLabel", (PyCFunction)Icn_GetLabel, 1,
"(SInt16 labelNumber, Str255 labelString) -> (RGBColor labelColor)"},
PyDoc_STR("(SInt16 labelNumber, Str255 labelString) -> (RGBColor labelColor)")},
{"PtInIconID", (PyCFunction)Icn_PtInIconID, 1,
"(Point testPt, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> (Boolean _rv)"},
PyDoc_STR("(Point testPt, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> (Boolean _rv)")},
{"PtInIconSuite", (PyCFunction)Icn_PtInIconSuite, 1,
"(Point testPt, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> (Boolean _rv)"},
PyDoc_STR("(Point testPt, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> (Boolean _rv)")},
{"RectInIconID", (PyCFunction)Icn_RectInIconID, 1,
"(Rect testRect, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> (Boolean _rv)"},
PyDoc_STR("(Rect testRect, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> (Boolean _rv)")},
{"RectInIconSuite", (PyCFunction)Icn_RectInIconSuite, 1,
"(Rect testRect, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> (Boolean _rv)"},
PyDoc_STR("(Rect testRect, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> (Boolean _rv)")},
{"IconIDToRgn", (PyCFunction)Icn_IconIDToRgn, 1,
"(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> None"},
PyDoc_STR("(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, SInt16 iconID) -> None")},
{"IconSuiteToRgn", (PyCFunction)Icn_IconSuiteToRgn, 1,
"(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> None"},
PyDoc_STR("(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, IconSuiteRef theIconSuite) -> None")},
{"SetSuiteLabel", (PyCFunction)Icn_SetSuiteLabel, 1,
"(IconSuiteRef theSuite, SInt16 theLabel) -> None"},
PyDoc_STR("(IconSuiteRef theSuite, SInt16 theLabel) -> None")},
{"GetSuiteLabel", (PyCFunction)Icn_GetSuiteLabel, 1,
"(IconSuiteRef theSuite) -> (SInt16 _rv)"},
PyDoc_STR("(IconSuiteRef theSuite) -> (SInt16 _rv)")},
{"PlotIconHandle", (PyCFunction)Icn_PlotIconHandle, 1,
"(Rect theRect, IconAlignmentType align, IconTransformType transform, Handle theIcon) -> None"},
PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, Handle theIcon) -> None")},
{"PlotSICNHandle", (PyCFunction)Icn_PlotSICNHandle, 1,
"(Rect theRect, IconAlignmentType align, IconTransformType transform, Handle theSICN) -> None"},
PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, Handle theSICN) -> None")},
{"PlotCIconHandle", (PyCFunction)Icn_PlotCIconHandle, 1,
"(Rect theRect, IconAlignmentType align, IconTransformType transform, CIconHandle theCIcon) -> None"},
PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, CIconHandle theCIcon) -> None")},
#if !TARGET_API_MAC_CARBON
{"IconServicesTerminate", (PyCFunction)Icn_IconServicesTerminate, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
{"IconRefToIconFamily", (PyCFunction)Icn_IconRefToIconFamily, 1,
"(IconRef theIconRef, IconSelectorValue whichIcons) -> (IconFamilyHandle iconFamily)"},
PyDoc_STR("(IconRef theIconRef, IconSelectorValue whichIcons) -> (IconFamilyHandle iconFamily)")},
{"IconFamilyToIconSuite", (PyCFunction)Icn_IconFamilyToIconSuite, 1,
"(IconFamilyHandle iconFamily, IconSelectorValue whichIcons) -> (IconSuiteRef iconSuite)"},
PyDoc_STR("(IconFamilyHandle iconFamily, IconSelectorValue whichIcons) -> (IconSuiteRef iconSuite)")},
{"IconSuiteToIconFamily", (PyCFunction)Icn_IconSuiteToIconFamily, 1,
"(IconSuiteRef iconSuite, IconSelectorValue whichIcons) -> (IconFamilyHandle iconFamily)"},
PyDoc_STR("(IconSuiteRef iconSuite, IconSelectorValue whichIcons) -> (IconFamilyHandle iconFamily)")},
{"SetIconFamilyData", (PyCFunction)Icn_SetIconFamilyData, 1,
"(IconFamilyHandle iconFamily, OSType iconType, Handle h) -> None"},
PyDoc_STR("(IconFamilyHandle iconFamily, OSType iconType, Handle h) -> None")},
{"GetIconFamilyData", (PyCFunction)Icn_GetIconFamilyData, 1,
"(IconFamilyHandle iconFamily, OSType iconType, Handle h) -> None"},
PyDoc_STR("(IconFamilyHandle iconFamily, OSType iconType, Handle h) -> None")},
{"GetIconRefOwners", (PyCFunction)Icn_GetIconRefOwners, 1,
"(IconRef theIconRef) -> (UInt16 owners)"},
PyDoc_STR("(IconRef theIconRef) -> (UInt16 owners)")},
{"AcquireIconRef", (PyCFunction)Icn_AcquireIconRef, 1,
"(IconRef theIconRef) -> None"},
PyDoc_STR("(IconRef theIconRef) -> None")},
{"ReleaseIconRef", (PyCFunction)Icn_ReleaseIconRef, 1,
"(IconRef theIconRef) -> None"},
PyDoc_STR("(IconRef theIconRef) -> None")},
{"GetIconRefFromFile", (PyCFunction)Icn_GetIconRefFromFile, 1,
"(FSSpec theFile) -> (IconRef theIconRef, SInt16 theLabel)"},
PyDoc_STR("(FSSpec theFile) -> (IconRef theIconRef, SInt16 theLabel)")},
{"GetIconRef", (PyCFunction)Icn_GetIconRef, 1,
"(SInt16 vRefNum, OSType creator, OSType iconType) -> (IconRef theIconRef)"},
PyDoc_STR("(SInt16 vRefNum, OSType creator, OSType iconType) -> (IconRef theIconRef)")},
{"GetIconRefFromFolder", (PyCFunction)Icn_GetIconRefFromFolder, 1,
"(SInt16 vRefNum, SInt32 parentFolderID, SInt32 folderID, SInt8 attributes, SInt8 accessPrivileges) -> (IconRef theIconRef)"},
PyDoc_STR("(SInt16 vRefNum, SInt32 parentFolderID, SInt32 folderID, SInt8 attributes, SInt8 accessPrivileges) -> (IconRef theIconRef)")},
{"RegisterIconRefFromIconFamily", (PyCFunction)Icn_RegisterIconRefFromIconFamily, 1,
"(OSType creator, OSType iconType, IconFamilyHandle iconFamily) -> (IconRef theIconRef)"},
PyDoc_STR("(OSType creator, OSType iconType, IconFamilyHandle iconFamily) -> (IconRef theIconRef)")},
{"RegisterIconRefFromResource", (PyCFunction)Icn_RegisterIconRefFromResource, 1,
"(OSType creator, OSType iconType, FSSpec resourceFile, SInt16 resourceID) -> (IconRef theIconRef)"},
PyDoc_STR("(OSType creator, OSType iconType, FSSpec resourceFile, SInt16 resourceID) -> (IconRef theIconRef)")},
{"UnregisterIconRef", (PyCFunction)Icn_UnregisterIconRef, 1,
"(OSType creator, OSType iconType) -> None"},
PyDoc_STR("(OSType creator, OSType iconType) -> None")},
{"UpdateIconRef", (PyCFunction)Icn_UpdateIconRef, 1,
"(IconRef theIconRef) -> None"},
PyDoc_STR("(IconRef theIconRef) -> None")},
{"OverrideIconRefFromResource", (PyCFunction)Icn_OverrideIconRefFromResource, 1,
"(IconRef theIconRef, FSSpec resourceFile, SInt16 resourceID) -> None"},
PyDoc_STR("(IconRef theIconRef, FSSpec resourceFile, SInt16 resourceID) -> None")},
{"OverrideIconRef", (PyCFunction)Icn_OverrideIconRef, 1,
"(IconRef oldIconRef, IconRef newIconRef) -> None"},
PyDoc_STR("(IconRef oldIconRef, IconRef newIconRef) -> None")},
{"RemoveIconRefOverride", (PyCFunction)Icn_RemoveIconRefOverride, 1,
"(IconRef theIconRef) -> None"},
PyDoc_STR("(IconRef theIconRef) -> None")},
{"CompositeIconRef", (PyCFunction)Icn_CompositeIconRef, 1,
"(IconRef backgroundIconRef, IconRef foregroundIconRef) -> (IconRef compositeIconRef)"},
PyDoc_STR("(IconRef backgroundIconRef, IconRef foregroundIconRef) -> (IconRef compositeIconRef)")},
{"IsIconRefComposite", (PyCFunction)Icn_IsIconRefComposite, 1,
"(IconRef compositeIconRef) -> (IconRef backgroundIconRef, IconRef foregroundIconRef)"},
PyDoc_STR("(IconRef compositeIconRef) -> (IconRef backgroundIconRef, IconRef foregroundIconRef)")},
{"IsValidIconRef", (PyCFunction)Icn_IsValidIconRef, 1,
"(IconRef theIconRef) -> (Boolean _rv)"},
PyDoc_STR("(IconRef theIconRef) -> (Boolean _rv)")},
{"PlotIconRef", (PyCFunction)Icn_PlotIconRef, 1,
"(Rect theRect, IconAlignmentType align, IconTransformType transform, IconServicesUsageFlags theIconServicesUsageFlags, IconRef theIconRef) -> None"},
PyDoc_STR("(Rect theRect, IconAlignmentType align, IconTransformType transform, IconServicesUsageFlags theIconServicesUsageFlags, IconRef theIconRef) -> None")},
{"PtInIconRef", (PyCFunction)Icn_PtInIconRef, 1,
"(Point testPt, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags theIconServicesUsageFlags, IconRef theIconRef) -> (Boolean _rv)"},
PyDoc_STR("(Point testPt, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags theIconServicesUsageFlags, IconRef theIconRef) -> (Boolean _rv)")},
{"RectInIconRef", (PyCFunction)Icn_RectInIconRef, 1,
"(Rect testRect, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> (Boolean _rv)"},
PyDoc_STR("(Rect testRect, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> (Boolean _rv)")},
{"IconRefToRgn", (PyCFunction)Icn_IconRefToRgn, 1,
"(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> None"},
PyDoc_STR("(RgnHandle theRgn, Rect iconRect, IconAlignmentType align, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> None")},
{"GetIconSizesFromIconRef", (PyCFunction)Icn_GetIconSizesFromIconRef, 1,
"(IconSelectorValue iconSelectorInput, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> (IconSelectorValue iconSelectorOutputPtr)"},
PyDoc_STR("(IconSelectorValue iconSelectorInput, IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef) -> (IconSelectorValue iconSelectorOutputPtr)")},
{"FlushIconRefs", (PyCFunction)Icn_FlushIconRefs, 1,
"(OSType creator, OSType iconType) -> None"},
PyDoc_STR("(OSType creator, OSType iconType) -> None")},
{"FlushIconRefsByVolume", (PyCFunction)Icn_FlushIconRefsByVolume, 1,
"(SInt16 vRefNum) -> None"},
PyDoc_STR("(SInt16 vRefNum) -> None")},
{"SetCustomIconsEnabled", (PyCFunction)Icn_SetCustomIconsEnabled, 1,
"(SInt16 vRefNum, Boolean enableCustomIcons) -> None"},
PyDoc_STR("(SInt16 vRefNum, Boolean enableCustomIcons) -> None")},
{"GetCustomIconsEnabled", (PyCFunction)Icn_GetCustomIconsEnabled, 1,
"(SInt16 vRefNum) -> (Boolean customIconsEnabled)"},
PyDoc_STR("(SInt16 vRefNum) -> (Boolean customIconsEnabled)")},
{"IsIconRefMaskEmpty", (PyCFunction)Icn_IsIconRefMaskEmpty, 1,
"(IconRef iconRef) -> (Boolean _rv)"},
PyDoc_STR("(IconRef iconRef) -> (Boolean _rv)")},
#if TARGET_API_MAC_CARBON
{"GetIconRefVariant", (PyCFunction)Icn_GetIconRefVariant, 1,
"(IconRef inIconRef, OSType inVariant) -> (IconRef _rv, IconTransformType outTransform)"},
PyDoc_STR("(IconRef inIconRef, OSType inVariant) -> (IconRef _rv, IconTransformType outTransform)")},
#endif
#if TARGET_API_MAC_CARBON
{"RegisterIconRefFromIconFile", (PyCFunction)Icn_RegisterIconRefFromIconFile, 1,
"(OSType creator, OSType iconType, FSSpec iconFile) -> (IconRef theIconRef)"},
PyDoc_STR("(OSType creator, OSType iconType, FSSpec iconFile) -> (IconRef theIconRef)")},
#endif
#if TARGET_API_MAC_CARBON
{"ReadIconFile", (PyCFunction)Icn_ReadIconFile, 1,
"(FSSpec iconFile) -> (IconFamilyHandle iconFamily)"},
PyDoc_STR("(FSSpec iconFile) -> (IconFamilyHandle iconFamily)")},
#endif
#if TARGET_API_MAC_CARBON
{"WriteIconFile", (PyCFunction)Icn_WriteIconFile, 1,
"(IconFamilyHandle iconFamily, FSSpec iconFile) -> None"},
PyDoc_STR("(IconFamilyHandle iconFamily, FSSpec iconFile) -> None")},
#endif
{NULL, NULL, 0}
};

92
Mac/Modules/list/_Listmodule.c
View File

@ -556,53 +556,53 @@ static PyObject *ListObj_as_Resource(ListObject *_self, PyObject *_args)
static PyMethodDef ListObj_methods[] = {
{"LAddColumn", (PyCFunction)ListObj_LAddColumn, 1,
"(short count, short colNum) -> (short _rv)"},
PyDoc_STR("(short count, short colNum) -> (short _rv)")},
{"LAddRow", (PyCFunction)ListObj_LAddRow, 1,
"(short count, short rowNum) -> (short _rv)"},
PyDoc_STR("(short count, short rowNum) -> (short _rv)")},
{"LDelColumn", (PyCFunction)ListObj_LDelColumn, 1,
"(short count, short colNum) -> None"},
PyDoc_STR("(short count, short colNum) -> None")},
{"LDelRow", (PyCFunction)ListObj_LDelRow, 1,
"(short count, short rowNum) -> None"},
PyDoc_STR("(short count, short rowNum) -> None")},
{"LGetSelect", (PyCFunction)ListObj_LGetSelect, 1,
"(Boolean next, Point theCell) -> (Boolean _rv, Point theCell)"},
PyDoc_STR("(Boolean next, Point theCell) -> (Boolean _rv, Point theCell)")},
{"LLastClick", (PyCFunction)ListObj_LLastClick, 1,
"() -> (Point _rv)"},
PyDoc_STR("() -> (Point _rv)")},
{"LNextCell", (PyCFunction)ListObj_LNextCell, 1,
"(Boolean hNext, Boolean vNext, Point theCell) -> (Boolean _rv, Point theCell)"},
PyDoc_STR("(Boolean hNext, Boolean vNext, Point theCell) -> (Boolean _rv, Point theCell)")},
{"LSize", (PyCFunction)ListObj_LSize, 1,
"(short listWidth, short listHeight) -> None"},
PyDoc_STR("(short listWidth, short listHeight) -> None")},
{"LSetDrawingMode", (PyCFunction)ListObj_LSetDrawingMode, 1,
"(Boolean drawIt) -> None"},
PyDoc_STR("(Boolean drawIt) -> None")},
{"LScroll", (PyCFunction)ListObj_LScroll, 1,
"(short dCols, short dRows) -> None"},
PyDoc_STR("(short dCols, short dRows) -> None")},
{"LAutoScroll", (PyCFunction)ListObj_LAutoScroll, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"LUpdate", (PyCFunction)ListObj_LUpdate, 1,
"(RgnHandle theRgn) -> None"},
PyDoc_STR("(RgnHandle theRgn) -> None")},
{"LActivate", (PyCFunction)ListObj_LActivate, 1,
"(Boolean act) -> None"},
PyDoc_STR("(Boolean act) -> None")},
{"LCellSize", (PyCFunction)ListObj_LCellSize, 1,
"(Point cSize) -> None"},
PyDoc_STR("(Point cSize) -> None")},
{"LClick", (PyCFunction)ListObj_LClick, 1,
"(Point pt, EventModifiers modifiers) -> (Boolean _rv)"},
PyDoc_STR("(Point pt, EventModifiers modifiers) -> (Boolean _rv)")},
{"LAddToCell", (PyCFunction)ListObj_LAddToCell, 1,
"(Buffer dataPtr, Point theCell) -> None"},
PyDoc_STR("(Buffer dataPtr, Point theCell) -> None")},
{"LClrCell", (PyCFunction)ListObj_LClrCell, 1,
"(Point theCell) -> None"},
PyDoc_STR("(Point theCell) -> None")},
{"LGetCell", (PyCFunction)ListObj_LGetCell, 1,
"(Buffer dataPtr, Point theCell) -> (Buffer dataPtr)"},
PyDoc_STR("(Buffer dataPtr, Point theCell) -> (Buffer dataPtr)")},
{"LRect", (PyCFunction)ListObj_LRect, 1,
"(Point theCell) -> (Rect cellRect)"},
PyDoc_STR("(Point theCell) -> (Rect cellRect)")},
{"LSetCell", (PyCFunction)ListObj_LSetCell, 1,
"(Buffer dataPtr, Point theCell) -> None"},
PyDoc_STR("(Buffer dataPtr, Point theCell) -> None")},
{"LSetSelect", (PyCFunction)ListObj_LSetSelect, 1,
"(Boolean setIt, Point theCell) -> None"},
PyDoc_STR("(Boolean setIt, Point theCell) -> None")},
{"LDraw", (PyCFunction)ListObj_LDraw, 1,
"(Point theCell) -> None"},
PyDoc_STR("(Point theCell) -> None")},
{"LGetCellDataLocation", (PyCFunction)ListObj_LGetCellDataLocation, 1,
"(Point theCell) -> (short offset, short len)"},
PyDoc_STR("(Point theCell) -> (short offset, short len)")},
{"as_Resource", (PyCFunction)ListObj_as_Resource, 1,
"() -> (Handle _rv)"},
PyDoc_STR("() -> (Handle _rv)")},
{NULL, NULL, 0}
};
@ -1082,49 +1082,49 @@ static PyObject *List_as_List(PyObject *_self, PyObject *_args)
static PyMethodDef List_methods[] = {
{"CreateCustomList", (PyCFunction)List_CreateCustomList, 1,
"(Rect rView, Rect dataBounds, Point cellSize, ListDefSpec theSpec, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListHandle outList)"},
PyDoc_STR("(Rect rView, Rect dataBounds, Point cellSize, ListDefSpec theSpec, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListHandle outList)")},
{"LNew", (PyCFunction)List_LNew, 1,
"(Rect rView, Rect dataBounds, Point cSize, short theProc, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListHandle _rv)"},
PyDoc_STR("(Rect rView, Rect dataBounds, Point cSize, short theProc, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert) -> (ListHandle _rv)")},
{"GetListPort", (PyCFunction)List_GetListPort, 1,
"(ListHandle list) -> (CGrafPtr _rv)"},
PyDoc_STR("(ListHandle list) -> (CGrafPtr _rv)")},
{"GetListVerticalScrollBar", (PyCFunction)List_GetListVerticalScrollBar, 1,
"(ListHandle list) -> (ControlHandle _rv)"},
PyDoc_STR("(ListHandle list) -> (ControlHandle _rv)")},
{"GetListHorizontalScrollBar", (PyCFunction)List_GetListHorizontalScrollBar, 1,
"(ListHandle list) -> (ControlHandle _rv)"},
PyDoc_STR("(ListHandle list) -> (ControlHandle _rv)")},
{"GetListActive", (PyCFunction)List_GetListActive, 1,
"(ListHandle list) -> (Boolean _rv)"},
PyDoc_STR("(ListHandle list) -> (Boolean _rv)")},
{"GetListClickTime", (PyCFunction)List_GetListClickTime, 1,
"(ListHandle list) -> (SInt32 _rv)"},
PyDoc_STR("(ListHandle list) -> (SInt32 _rv)")},
{"GetListRefCon", (PyCFunction)List_GetListRefCon, 1,
"(ListHandle list) -> (SInt32 _rv)"},
PyDoc_STR("(ListHandle list) -> (SInt32 _rv)")},
{"GetListDefinition", (PyCFunction)List_GetListDefinition, 1,
"(ListHandle list) -> (Handle _rv)"},
PyDoc_STR("(ListHandle list) -> (Handle _rv)")},
{"GetListUserHandle", (PyCFunction)List_GetListUserHandle, 1,
"(ListHandle list) -> (Handle _rv)"},
PyDoc_STR("(ListHandle list) -> (Handle _rv)")},
{"GetListDataHandle", (PyCFunction)List_GetListDataHandle, 1,
"(ListHandle list) -> (DataHandle _rv)"},
PyDoc_STR("(ListHandle list) -> (DataHandle _rv)")},
{"GetListFlags", (PyCFunction)List_GetListFlags, 1,
"(ListHandle list) -> (OptionBits _rv)"},
PyDoc_STR("(ListHandle list) -> (OptionBits _rv)")},
{"GetListSelectionFlags", (PyCFunction)List_GetListSelectionFlags, 1,
"(ListHandle list) -> (OptionBits _rv)"},
PyDoc_STR("(ListHandle list) -> (OptionBits _rv)")},
{"SetListViewBounds", (PyCFunction)List_SetListViewBounds, 1,
"(ListHandle list, Rect view) -> None"},
PyDoc_STR("(ListHandle list, Rect view) -> None")},
{"SetListPort", (PyCFunction)List_SetListPort, 1,
"(ListHandle list, CGrafPtr port) -> None"},
PyDoc_STR("(ListHandle list, CGrafPtr port) -> None")},
{"SetListCellIndent", (PyCFunction)List_SetListCellIndent, 1,
"(ListHandle list, Point indent) -> None"},
PyDoc_STR("(ListHandle list, Point indent) -> None")},
{"SetListClickTime", (PyCFunction)List_SetListClickTime, 1,
"(ListHandle list, SInt32 time) -> None"},
PyDoc_STR("(ListHandle list, SInt32 time) -> None")},
{"SetListRefCon", (PyCFunction)List_SetListRefCon, 1,
"(ListHandle list, SInt32 refCon) -> None"},
PyDoc_STR("(ListHandle list, SInt32 refCon) -> None")},
{"SetListUserHandle", (PyCFunction)List_SetListUserHandle, 1,
"(ListHandle list, Handle userHandle) -> None"},
PyDoc_STR("(ListHandle list, Handle userHandle) -> None")},
{"SetListFlags", (PyCFunction)List_SetListFlags, 1,
"(ListHandle list, OptionBits listFlags) -> None"},
PyDoc_STR("(ListHandle list, OptionBits listFlags) -> None")},
{"SetListSelectionFlags", (PyCFunction)List_SetListSelectionFlags, 1,
"(ListHandle list, OptionBits selectionFlags) -> None"},
PyDoc_STR("(ListHandle list, OptionBits selectionFlags) -> None")},
{"as_List", (PyCFunction)List_as_List, 1,
"(Resource)->List.\nReturns List object (which is not auto-freed!)"},
PyDoc_STR("(Resource)->List.\nReturns List object (which is not auto-freed!)")},
{NULL, NULL, 0}
};

332
Mac/Modules/menu/_Menumodule.c
View File

@ -2597,406 +2597,406 @@ static PyObject *MenuObj_CheckMenuItem(MenuObject *_self, PyObject *_args)
static PyMethodDef MenuObj_methods[] = {
{"DisposeMenu", (PyCFunction)MenuObj_DisposeMenu, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CalcMenuSize", (PyCFunction)MenuObj_CalcMenuSize, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#if !TARGET_API_MAC_CARBON
{"CountMItems", (PyCFunction)MenuObj_CountMItems, 1,
"() -> (short _rv)"},
PyDoc_STR("() -> (short _rv)")},
#endif
{"CountMenuItems", (PyCFunction)MenuObj_CountMenuItems, 1,
"() -> (short _rv)"},
PyDoc_STR("() -> (short _rv)")},
{"GetMenuFont", (PyCFunction)MenuObj_GetMenuFont, 1,
"() -> (SInt16 outFontID, UInt16 outFontSize)"},
PyDoc_STR("() -> (SInt16 outFontID, UInt16 outFontSize)")},
{"SetMenuFont", (PyCFunction)MenuObj_SetMenuFont, 1,
"(SInt16 inFontID, UInt16 inFontSize) -> None"},
PyDoc_STR("(SInt16 inFontID, UInt16 inFontSize) -> None")},
{"GetMenuExcludesMarkColumn", (PyCFunction)MenuObj_GetMenuExcludesMarkColumn, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
{"SetMenuExcludesMarkColumn", (PyCFunction)MenuObj_SetMenuExcludesMarkColumn, 1,
"(Boolean excludesMark) -> None"},
PyDoc_STR("(Boolean excludesMark) -> None")},
#if TARGET_API_MAC_CARBON
{"IsValidMenu", (PyCFunction)MenuObj_IsValidMenu, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
#endif
#if TARGET_API_MAC_CARBON
{"GetMenuRetainCount", (PyCFunction)MenuObj_GetMenuRetainCount, 1,
"() -> (ItemCount _rv)"},
PyDoc_STR("() -> (ItemCount _rv)")},
#endif
#if TARGET_API_MAC_CARBON
{"RetainMenu", (PyCFunction)MenuObj_RetainMenu, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"ReleaseMenu", (PyCFunction)MenuObj_ReleaseMenu, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"DuplicateMenu", (PyCFunction)MenuObj_DuplicateMenu, 1,
"() -> (MenuHandle outMenu)"},
PyDoc_STR("() -> (MenuHandle outMenu)")},
#endif
#if TARGET_API_MAC_CARBON
{"CopyMenuTitleAsCFString", (PyCFunction)MenuObj_CopyMenuTitleAsCFString, 1,
"() -> (CFStringRef outString)"},
PyDoc_STR("() -> (CFStringRef outString)")},
#endif
#if TARGET_API_MAC_CARBON
{"SetMenuTitleWithCFString", (PyCFunction)MenuObj_SetMenuTitleWithCFString, 1,
"(CFStringRef inString) -> None"},
PyDoc_STR("(CFStringRef inString) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"InvalidateMenuSize", (PyCFunction)MenuObj_InvalidateMenuSize, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"IsMenuSizeInvalid", (PyCFunction)MenuObj_IsMenuSizeInvalid, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
#endif
{"MacAppendMenu", (PyCFunction)MenuObj_MacAppendMenu, 1,
"(Str255 data) -> None"},
PyDoc_STR("(Str255 data) -> None")},
{"InsertResMenu", (PyCFunction)MenuObj_InsertResMenu, 1,
"(ResType theType, short afterItem) -> None"},
PyDoc_STR("(ResType theType, short afterItem) -> None")},
{"AppendResMenu", (PyCFunction)MenuObj_AppendResMenu, 1,
"(ResType theType) -> None"},
PyDoc_STR("(ResType theType) -> None")},
{"MacInsertMenuItem", (PyCFunction)MenuObj_MacInsertMenuItem, 1,
"(Str255 itemString, short afterItem) -> None"},
PyDoc_STR("(Str255 itemString, short afterItem) -> None")},
{"DeleteMenuItem", (PyCFunction)MenuObj_DeleteMenuItem, 1,
"(short item) -> None"},
PyDoc_STR("(short item) -> None")},
{"InsertFontResMenu", (PyCFunction)MenuObj_InsertFontResMenu, 1,
"(short afterItem, short scriptFilter) -> None"},
PyDoc_STR("(short afterItem, short scriptFilter) -> None")},
{"InsertIntlResMenu", (PyCFunction)MenuObj_InsertIntlResMenu, 1,
"(ResType theType, short afterItem, short scriptFilter) -> None"},
PyDoc_STR("(ResType theType, short afterItem, short scriptFilter) -> None")},
{"AppendMenuItemText", (PyCFunction)MenuObj_AppendMenuItemText, 1,
"(Str255 inString) -> None"},
PyDoc_STR("(Str255 inString) -> None")},
{"InsertMenuItemText", (PyCFunction)MenuObj_InsertMenuItemText, 1,
"(Str255 inString, MenuItemIndex afterItem) -> None"},
PyDoc_STR("(Str255 inString, MenuItemIndex afterItem) -> None")},
#if TARGET_API_MAC_CARBON
{"CopyMenuItems", (PyCFunction)MenuObj_CopyMenuItems, 1,
"(MenuItemIndex inFirstItem, ItemCount inNumItems, MenuHandle inDestMenu, MenuItemIndex inInsertAfter) -> None"},
PyDoc_STR("(MenuItemIndex inFirstItem, ItemCount inNumItems, MenuHandle inDestMenu, MenuItemIndex inInsertAfter) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"DeleteMenuItems", (PyCFunction)MenuObj_DeleteMenuItems, 1,
"(MenuItemIndex inFirstItem, ItemCount inNumItems) -> None"},
PyDoc_STR("(MenuItemIndex inFirstItem, ItemCount inNumItems) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"AppendMenuItemTextWithCFString", (PyCFunction)MenuObj_AppendMenuItemTextWithCFString, 1,
"(CFStringRef inString, MenuItemAttributes inAttributes, MenuCommand inCommandID) -> (MenuItemIndex outNewItem)"},
PyDoc_STR("(CFStringRef inString, MenuItemAttributes inAttributes, MenuCommand inCommandID) -> (MenuItemIndex outNewItem)")},
#endif
#if TARGET_API_MAC_CARBON
{"InsertMenuItemTextWithCFString", (PyCFunction)MenuObj_InsertMenuItemTextWithCFString, 1,
"(CFStringRef inString, MenuItemIndex inAfterItem, MenuItemAttributes inAttributes, MenuCommand inCommandID) -> None"},
PyDoc_STR("(CFStringRef inString, MenuItemIndex inAfterItem, MenuItemAttributes inAttributes, MenuCommand inCommandID) -> None")},
#endif
{"PopUpMenuSelect", (PyCFunction)MenuObj_PopUpMenuSelect, 1,
"(short top, short left, short popUpItem) -> (long _rv)"},
PyDoc_STR("(short top, short left, short popUpItem) -> (long _rv)")},
#if TARGET_API_MAC_CARBON
{"InvalidateMenuEnabling", (PyCFunction)MenuObj_InvalidateMenuEnabling, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"IsMenuBarInvalid", (PyCFunction)MenuObj_IsMenuBarInvalid, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
#endif
{"MacInsertMenu", (PyCFunction)MenuObj_MacInsertMenu, 1,
"(MenuID beforeID) -> None"},
PyDoc_STR("(MenuID beforeID) -> None")},
#if TARGET_API_MAC_CARBON
{"SetRootMenu", (PyCFunction)MenuObj_SetRootMenu, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
#if !TARGET_API_MAC_CARBON
{"CheckItem", (PyCFunction)MenuObj_CheckItem, 1,
"(short item, Boolean checked) -> None"},
PyDoc_STR("(short item, Boolean checked) -> None")},
#endif
{"MacCheckMenuItem", (PyCFunction)MenuObj_MacCheckMenuItem, 1,
"(short item, Boolean checked) -> None"},
PyDoc_STR("(short item, Boolean checked) -> None")},
{"SetMenuItemText", (PyCFunction)MenuObj_SetMenuItemText, 1,
"(short item, Str255 itemString) -> None"},
PyDoc_STR("(short item, Str255 itemString) -> None")},
{"GetMenuItemText", (PyCFunction)MenuObj_GetMenuItemText, 1,
"(short item) -> (Str255 itemString)"},
PyDoc_STR("(short item) -> (Str255 itemString)")},
{"SetItemMark", (PyCFunction)MenuObj_SetItemMark, 1,
"(short item, CharParameter markChar) -> None"},
PyDoc_STR("(short item, CharParameter markChar) -> None")},
{"GetItemMark", (PyCFunction)MenuObj_GetItemMark, 1,
"(short item) -> (CharParameter markChar)"},
PyDoc_STR("(short item) -> (CharParameter markChar)")},
{"SetItemCmd", (PyCFunction)MenuObj_SetItemCmd, 1,
"(short item, CharParameter cmdChar) -> None"},
PyDoc_STR("(short item, CharParameter cmdChar) -> None")},
{"GetItemCmd", (PyCFunction)MenuObj_GetItemCmd, 1,
"(short item) -> (CharParameter cmdChar)"},
PyDoc_STR("(short item) -> (CharParameter cmdChar)")},
{"SetItemIcon", (PyCFunction)MenuObj_SetItemIcon, 1,
"(short item, short iconIndex) -> None"},
PyDoc_STR("(short item, short iconIndex) -> None")},
{"GetItemIcon", (PyCFunction)MenuObj_GetItemIcon, 1,
"(short item) -> (short iconIndex)"},
PyDoc_STR("(short item) -> (short iconIndex)")},
{"SetItemStyle", (PyCFunction)MenuObj_SetItemStyle, 1,
"(short item, StyleParameter chStyle) -> None"},
PyDoc_STR("(short item, StyleParameter chStyle) -> None")},
{"GetItemStyle", (PyCFunction)MenuObj_GetItemStyle, 1,
"(short item) -> (Style chStyle)"},
PyDoc_STR("(short item) -> (Style chStyle)")},
#if !TARGET_API_MAC_CARBON
{"DisableItem", (PyCFunction)MenuObj_DisableItem, 1,
"(short item) -> None"},
PyDoc_STR("(short item) -> None")},
#endif
#if !TARGET_API_MAC_CARBON
{"EnableItem", (PyCFunction)MenuObj_EnableItem, 1,
"(short item) -> None"},
PyDoc_STR("(short item) -> None")},
#endif
{"SetMenuItemCommandID", (PyCFunction)MenuObj_SetMenuItemCommandID, 1,
"(SInt16 inItem, MenuCommand inCommandID) -> None"},
PyDoc_STR("(SInt16 inItem, MenuCommand inCommandID) -> None")},
{"GetMenuItemCommandID", (PyCFunction)MenuObj_GetMenuItemCommandID, 1,
"(SInt16 inItem) -> (MenuCommand outCommandID)"},
PyDoc_STR("(SInt16 inItem) -> (MenuCommand outCommandID)")},
{"SetMenuItemModifiers", (PyCFunction)MenuObj_SetMenuItemModifiers, 1,
"(SInt16 inItem, UInt8 inModifiers) -> None"},
PyDoc_STR("(SInt16 inItem, UInt8 inModifiers) -> None")},
{"GetMenuItemModifiers", (PyCFunction)MenuObj_GetMenuItemModifiers, 1,
"(SInt16 inItem) -> (UInt8 outModifiers)"},
PyDoc_STR("(SInt16 inItem) -> (UInt8 outModifiers)")},
{"SetMenuItemIconHandle", (PyCFunction)MenuObj_SetMenuItemIconHandle, 1,
"(SInt16 inItem, UInt8 inIconType, Handle inIconHandle) -> None"},
PyDoc_STR("(SInt16 inItem, UInt8 inIconType, Handle inIconHandle) -> None")},
{"GetMenuItemIconHandle", (PyCFunction)MenuObj_GetMenuItemIconHandle, 1,
"(SInt16 inItem) -> (UInt8 outIconType, Handle outIconHandle)"},
PyDoc_STR("(SInt16 inItem) -> (UInt8 outIconType, Handle outIconHandle)")},
{"SetMenuItemTextEncoding", (PyCFunction)MenuObj_SetMenuItemTextEncoding, 1,
"(SInt16 inItem, TextEncoding inScriptID) -> None"},
PyDoc_STR("(SInt16 inItem, TextEncoding inScriptID) -> None")},
{"GetMenuItemTextEncoding", (PyCFunction)MenuObj_GetMenuItemTextEncoding, 1,
"(SInt16 inItem) -> (TextEncoding outScriptID)"},
PyDoc_STR("(SInt16 inItem) -> (TextEncoding outScriptID)")},
{"SetMenuItemHierarchicalID", (PyCFunction)MenuObj_SetMenuItemHierarchicalID, 1,
"(SInt16 inItem, MenuID inHierID) -> None"},
PyDoc_STR("(SInt16 inItem, MenuID inHierID) -> None")},
{"GetMenuItemHierarchicalID", (PyCFunction)MenuObj_GetMenuItemHierarchicalID, 1,
"(SInt16 inItem) -> (MenuID outHierID)"},
PyDoc_STR("(SInt16 inItem) -> (MenuID outHierID)")},
{"SetMenuItemFontID", (PyCFunction)MenuObj_SetMenuItemFontID, 1,
"(SInt16 inItem, SInt16 inFontID) -> None"},
PyDoc_STR("(SInt16 inItem, SInt16 inFontID) -> None")},
{"GetMenuItemFontID", (PyCFunction)MenuObj_GetMenuItemFontID, 1,
"(SInt16 inItem) -> (SInt16 outFontID)"},
PyDoc_STR("(SInt16 inItem) -> (SInt16 outFontID)")},
{"SetMenuItemRefCon", (PyCFunction)MenuObj_SetMenuItemRefCon, 1,
"(SInt16 inItem, UInt32 inRefCon) -> None"},
PyDoc_STR("(SInt16 inItem, UInt32 inRefCon) -> None")},
{"GetMenuItemRefCon", (PyCFunction)MenuObj_GetMenuItemRefCon, 1,
"(SInt16 inItem) -> (UInt32 outRefCon)"},
PyDoc_STR("(SInt16 inItem) -> (UInt32 outRefCon)")},
#if !TARGET_API_MAC_CARBON
{"SetMenuItemRefCon2", (PyCFunction)MenuObj_SetMenuItemRefCon2, 1,
"(SInt16 inItem, UInt32 inRefCon2) -> None"},
PyDoc_STR("(SInt16 inItem, UInt32 inRefCon2) -> None")},
#endif
#if !TARGET_API_MAC_CARBON
{"GetMenuItemRefCon2", (PyCFunction)MenuObj_GetMenuItemRefCon2, 1,
"(SInt16 inItem) -> (UInt32 outRefCon2)"},
PyDoc_STR("(SInt16 inItem) -> (UInt32 outRefCon2)")},
#endif
{"SetMenuItemKeyGlyph", (PyCFunction)MenuObj_SetMenuItemKeyGlyph, 1,
"(SInt16 inItem, SInt16 inGlyph) -> None"},
PyDoc_STR("(SInt16 inItem, SInt16 inGlyph) -> None")},
{"GetMenuItemKeyGlyph", (PyCFunction)MenuObj_GetMenuItemKeyGlyph, 1,
"(SInt16 inItem) -> (SInt16 outGlyph)"},
PyDoc_STR("(SInt16 inItem) -> (SInt16 outGlyph)")},
{"MacEnableMenuItem", (PyCFunction)MenuObj_MacEnableMenuItem, 1,
"(MenuItemIndex item) -> None"},
PyDoc_STR("(MenuItemIndex item) -> None")},
{"DisableMenuItem", (PyCFunction)MenuObj_DisableMenuItem, 1,
"(MenuItemIndex item) -> None"},
PyDoc_STR("(MenuItemIndex item) -> None")},
{"IsMenuItemEnabled", (PyCFunction)MenuObj_IsMenuItemEnabled, 1,
"(MenuItemIndex item) -> (Boolean _rv)"},
PyDoc_STR("(MenuItemIndex item) -> (Boolean _rv)")},
{"EnableMenuItemIcon", (PyCFunction)MenuObj_EnableMenuItemIcon, 1,
"(MenuItemIndex item) -> None"},
PyDoc_STR("(MenuItemIndex item) -> None")},
{"DisableMenuItemIcon", (PyCFunction)MenuObj_DisableMenuItemIcon, 1,
"(MenuItemIndex item) -> None"},
PyDoc_STR("(MenuItemIndex item) -> None")},
{"IsMenuItemIconEnabled", (PyCFunction)MenuObj_IsMenuItemIconEnabled, 1,
"(MenuItemIndex item) -> (Boolean _rv)"},
PyDoc_STR("(MenuItemIndex item) -> (Boolean _rv)")},
#if TARGET_API_MAC_CARBON
{"SetMenuItemHierarchicalMenu", (PyCFunction)MenuObj_SetMenuItemHierarchicalMenu, 1,
"(MenuItemIndex inItem, MenuHandle inHierMenu) -> None"},
PyDoc_STR("(MenuItemIndex inItem, MenuHandle inHierMenu) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"GetMenuItemHierarchicalMenu", (PyCFunction)MenuObj_GetMenuItemHierarchicalMenu, 1,
"(MenuItemIndex inItem) -> (MenuHandle outHierMenu)"},
PyDoc_STR("(MenuItemIndex inItem) -> (MenuHandle outHierMenu)")},
#endif
#if TARGET_API_MAC_CARBON
{"CopyMenuItemTextAsCFString", (PyCFunction)MenuObj_CopyMenuItemTextAsCFString, 1,
"(MenuItemIndex inItem) -> (CFStringRef outString)"},
PyDoc_STR("(MenuItemIndex inItem) -> (CFStringRef outString)")},
#endif
#if TARGET_API_MAC_CARBON
{"SetMenuItemTextWithCFString", (PyCFunction)MenuObj_SetMenuItemTextWithCFString, 1,
"(MenuItemIndex inItem, CFStringRef inString) -> None"},
PyDoc_STR("(MenuItemIndex inItem, CFStringRef inString) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"GetMenuItemIndent", (PyCFunction)MenuObj_GetMenuItemIndent, 1,
"(MenuItemIndex inItem) -> (UInt32 outIndent)"},
PyDoc_STR("(MenuItemIndex inItem) -> (UInt32 outIndent)")},
#endif
#if TARGET_API_MAC_CARBON
{"SetMenuItemIndent", (PyCFunction)MenuObj_SetMenuItemIndent, 1,
"(MenuItemIndex inItem, UInt32 inIndent) -> None"},
PyDoc_STR("(MenuItemIndex inItem, UInt32 inIndent) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"GetMenuItemCommandKey", (PyCFunction)MenuObj_GetMenuItemCommandKey, 1,
"(MenuItemIndex inItem, Boolean inGetVirtualKey) -> (UInt16 outKey)"},
PyDoc_STR("(MenuItemIndex inItem, Boolean inGetVirtualKey) -> (UInt16 outKey)")},
#endif
#if TARGET_API_MAC_CARBON
{"SetMenuItemCommandKey", (PyCFunction)MenuObj_SetMenuItemCommandKey, 1,
"(MenuItemIndex inItem, Boolean inSetVirtualKey, UInt16 inKey) -> None"},
PyDoc_STR("(MenuItemIndex inItem, Boolean inSetVirtualKey, UInt16 inKey) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"GetMenuItemPropertyAttributes", (PyCFunction)MenuObj_GetMenuItemPropertyAttributes, 1,
"(MenuItemIndex item, OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)"},
PyDoc_STR("(MenuItemIndex item, OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)")},
#endif
#if TARGET_API_MAC_CARBON
{"ChangeMenuItemPropertyAttributes", (PyCFunction)MenuObj_ChangeMenuItemPropertyAttributes, 1,
"(MenuItemIndex item, OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None"},
PyDoc_STR("(MenuItemIndex item, OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"GetMenuAttributes", (PyCFunction)MenuObj_GetMenuAttributes, 1,
"() -> (MenuAttributes outAttributes)"},
PyDoc_STR("() -> (MenuAttributes outAttributes)")},
#endif
#if TARGET_API_MAC_CARBON
{"ChangeMenuAttributes", (PyCFunction)MenuObj_ChangeMenuAttributes, 1,
"(MenuAttributes setTheseAttributes, MenuAttributes clearTheseAttributes) -> None"},
PyDoc_STR("(MenuAttributes setTheseAttributes, MenuAttributes clearTheseAttributes) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"GetMenuItemAttributes", (PyCFunction)MenuObj_GetMenuItemAttributes, 1,
"(MenuItemIndex item) -> (MenuItemAttributes outAttributes)"},
PyDoc_STR("(MenuItemIndex item) -> (MenuItemAttributes outAttributes)")},
#endif
#if TARGET_API_MAC_CARBON
{"ChangeMenuItemAttributes", (PyCFunction)MenuObj_ChangeMenuItemAttributes, 1,
"(MenuItemIndex item, MenuItemAttributes setTheseAttributes, MenuItemAttributes clearTheseAttributes) -> None"},
PyDoc_STR("(MenuItemIndex item, MenuItemAttributes setTheseAttributes, MenuItemAttributes clearTheseAttributes) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"DisableAllMenuItems", (PyCFunction)MenuObj_DisableAllMenuItems, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"EnableAllMenuItems", (PyCFunction)MenuObj_EnableAllMenuItems, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"MenuHasEnabledItems", (PyCFunction)MenuObj_MenuHasEnabledItems, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
#endif
#if TARGET_API_MAC_CARBON
{"GetMenuType", (PyCFunction)MenuObj_GetMenuType, 1,
"() -> (UInt16 outType)"},
PyDoc_STR("() -> (UInt16 outType)")},
#endif
#if TARGET_API_MAC_CARBON
{"CountMenuItemsWithCommandID", (PyCFunction)MenuObj_CountMenuItemsWithCommandID, 1,
"(MenuCommand inCommandID) -> (ItemCount _rv)"},
PyDoc_STR("(MenuCommand inCommandID) -> (ItemCount _rv)")},
#endif
#if TARGET_API_MAC_CARBON
{"GetIndMenuItemWithCommandID", (PyCFunction)MenuObj_GetIndMenuItemWithCommandID, 1,
"(MenuCommand inCommandID, UInt32 inItemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)"},
PyDoc_STR("(MenuCommand inCommandID, UInt32 inItemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)")},
#endif
#if TARGET_API_MAC_CARBON
{"EnableMenuCommand", (PyCFunction)MenuObj_EnableMenuCommand, 1,
"(MenuCommand inCommandID) -> None"},
PyDoc_STR("(MenuCommand inCommandID) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"DisableMenuCommand", (PyCFunction)MenuObj_DisableMenuCommand, 1,
"(MenuCommand inCommandID) -> None"},
PyDoc_STR("(MenuCommand inCommandID) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"IsMenuCommandEnabled", (PyCFunction)MenuObj_IsMenuCommandEnabled, 1,
"(MenuCommand inCommandID) -> (Boolean _rv)"},
PyDoc_STR("(MenuCommand inCommandID) -> (Boolean _rv)")},
#endif
#if TARGET_API_MAC_CARBON
{"SetMenuCommandMark", (PyCFunction)MenuObj_SetMenuCommandMark, 1,
"(MenuCommand inCommandID, UniChar inMark) -> None"},
PyDoc_STR("(MenuCommand inCommandID, UniChar inMark) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"GetMenuCommandMark", (PyCFunction)MenuObj_GetMenuCommandMark, 1,
"(MenuCommand inCommandID) -> (UniChar outMark)"},
PyDoc_STR("(MenuCommand inCommandID) -> (UniChar outMark)")},
#endif
#if TARGET_API_MAC_CARBON
{"GetMenuCommandPropertySize", (PyCFunction)MenuObj_GetMenuCommandPropertySize, 1,
"(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> (ByteCount outSize)"},
PyDoc_STR("(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> (ByteCount outSize)")},
#endif
#if TARGET_API_MAC_CARBON
{"RemoveMenuCommandProperty", (PyCFunction)MenuObj_RemoveMenuCommandProperty, 1,
"(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> None"},
PyDoc_STR("(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"IsMenuItemInvalid", (PyCFunction)MenuObj_IsMenuItemInvalid, 1,
"(MenuItemIndex item) -> (Boolean _rv)"},
PyDoc_STR("(MenuItemIndex item) -> (Boolean _rv)")},
#endif
#if TARGET_API_MAC_CARBON
{"InvalidateMenuItems", (PyCFunction)MenuObj_InvalidateMenuItems, 1,
"(MenuItemIndex firstItem, ItemCount numItems) -> None"},
PyDoc_STR("(MenuItemIndex firstItem, ItemCount numItems) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"UpdateInvalidMenuItems", (PyCFunction)MenuObj_UpdateInvalidMenuItems, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"CreateStandardFontMenu", (PyCFunction)MenuObj_CreateStandardFontMenu, 1,
"(MenuItemIndex afterItem, MenuID firstHierMenuID, OptionBits options) -> (ItemCount outHierMenuCount)"},
PyDoc_STR("(MenuItemIndex afterItem, MenuID firstHierMenuID, OptionBits options) -> (ItemCount outHierMenuCount)")},
#endif
#if TARGET_API_MAC_CARBON
{"UpdateStandardFontMenu", (PyCFunction)MenuObj_UpdateStandardFontMenu, 1,
"() -> (ItemCount outHierMenuCount)"},
PyDoc_STR("() -> (ItemCount outHierMenuCount)")},
#endif
#if TARGET_API_MAC_CARBON
{"GetFontFamilyFromMenuSelection", (PyCFunction)MenuObj_GetFontFamilyFromMenuSelection, 1,
"(MenuItemIndex item) -> (FMFontFamily outFontFamily, FMFontStyle outStyle)"},
PyDoc_STR("(MenuItemIndex item) -> (FMFontFamily outFontFamily, FMFontStyle outStyle)")},
#endif
{"GetMenuID", (PyCFunction)MenuObj_GetMenuID, 1,
"() -> (MenuID _rv)"},
PyDoc_STR("() -> (MenuID _rv)")},
{"GetMenuWidth", (PyCFunction)MenuObj_GetMenuWidth, 1,
"() -> (SInt16 _rv)"},
PyDoc_STR("() -> (SInt16 _rv)")},
{"GetMenuHeight", (PyCFunction)MenuObj_GetMenuHeight, 1,
"() -> (SInt16 _rv)"},
PyDoc_STR("() -> (SInt16 _rv)")},
{"SetMenuID", (PyCFunction)MenuObj_SetMenuID, 1,
"(MenuID menuID) -> None"},
PyDoc_STR("(MenuID menuID) -> None")},
{"SetMenuWidth", (PyCFunction)MenuObj_SetMenuWidth, 1,
"(SInt16 width) -> None"},
PyDoc_STR("(SInt16 width) -> None")},
{"SetMenuHeight", (PyCFunction)MenuObj_SetMenuHeight, 1,
"(SInt16 height) -> None"},
PyDoc_STR("(SInt16 height) -> None")},
{"as_Resource", (PyCFunction)MenuObj_as_Resource, 1,
"() -> (Handle _rv)"},
PyDoc_STR("() -> (Handle _rv)")},
{"AppendMenu", (PyCFunction)MenuObj_AppendMenu, 1,
"(Str255 data) -> None"},
PyDoc_STR("(Str255 data) -> None")},
{"InsertMenu", (PyCFunction)MenuObj_InsertMenu, 1,
"(short beforeID) -> None"},
PyDoc_STR("(short beforeID) -> None")},
{"InsertMenuItem", (PyCFunction)MenuObj_InsertMenuItem, 1,
"(Str255 itemString, short afterItem) -> None"},
PyDoc_STR("(Str255 itemString, short afterItem) -> None")},
{"EnableMenuItem", (PyCFunction)MenuObj_EnableMenuItem, 1,
"(UInt16 item) -> None"},
PyDoc_STR("(UInt16 item) -> None")},
{"CheckMenuItem", (PyCFunction)MenuObj_CheckMenuItem, 1,
"(short item, Boolean checked) -> None"},
PyDoc_STR("(short item, Boolean checked) -> None")},
{NULL, NULL, 0}
};
@ -3942,155 +3942,155 @@ static PyMethodDef Menu_methods[] = {
#if !TARGET_API_MAC_CARBON
{"InitProcMenu", (PyCFunction)Menu_InitProcMenu, 1,
"(short resID) -> None"},
PyDoc_STR("(short resID) -> None")},
#endif
#if !TARGET_API_MAC_CARBON
{"InitMenus", (PyCFunction)Menu_InitMenus, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
{"NewMenu", (PyCFunction)Menu_NewMenu, 1,
"(MenuID menuID, Str255 menuTitle) -> (MenuHandle _rv)"},
PyDoc_STR("(MenuID menuID, Str255 menuTitle) -> (MenuHandle _rv)")},
{"MacGetMenu", (PyCFunction)Menu_MacGetMenu, 1,
"(short resourceID) -> (MenuHandle _rv)"},
PyDoc_STR("(short resourceID) -> (MenuHandle _rv)")},
#if TARGET_API_MAC_CARBON
{"CreateNewMenu", (PyCFunction)Menu_CreateNewMenu, 1,
"(MenuID inMenuID, MenuAttributes inMenuAttributes) -> (MenuHandle outMenuRef)"},
PyDoc_STR("(MenuID inMenuID, MenuAttributes inMenuAttributes) -> (MenuHandle outMenuRef)")},
#endif
{"MenuKey", (PyCFunction)Menu_MenuKey, 1,
"(CharParameter ch) -> (long _rv)"},
PyDoc_STR("(CharParameter ch) -> (long _rv)")},
{"MenuSelect", (PyCFunction)Menu_MenuSelect, 1,
"(Point startPt) -> (long _rv)"},
PyDoc_STR("(Point startPt) -> (long _rv)")},
{"MenuChoice", (PyCFunction)Menu_MenuChoice, 1,
"() -> (long _rv)"},
PyDoc_STR("() -> (long _rv)")},
{"MenuEvent", (PyCFunction)Menu_MenuEvent, 1,
"(EventRecord inEvent) -> (UInt32 _rv)"},
PyDoc_STR("(EventRecord inEvent) -> (UInt32 _rv)")},
{"GetMBarHeight", (PyCFunction)Menu_GetMBarHeight, 1,
"() -> (short _rv)"},
PyDoc_STR("() -> (short _rv)")},
{"MacDrawMenuBar", (PyCFunction)Menu_MacDrawMenuBar, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"InvalMenuBar", (PyCFunction)Menu_InvalMenuBar, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"HiliteMenu", (PyCFunction)Menu_HiliteMenu, 1,
"(MenuID menuID) -> None"},
PyDoc_STR("(MenuID menuID) -> None")},
{"GetNewMBar", (PyCFunction)Menu_GetNewMBar, 1,
"(short menuBarID) -> (MenuBarHandle _rv)"},
PyDoc_STR("(short menuBarID) -> (MenuBarHandle _rv)")},
{"GetMenuBar", (PyCFunction)Menu_GetMenuBar, 1,
"() -> (MenuBarHandle _rv)"},
PyDoc_STR("() -> (MenuBarHandle _rv)")},
{"SetMenuBar", (PyCFunction)Menu_SetMenuBar, 1,
"(MenuBarHandle mbar) -> None"},
PyDoc_STR("(MenuBarHandle mbar) -> None")},
#if TARGET_API_MAC_CARBON
{"DuplicateMenuBar", (PyCFunction)Menu_DuplicateMenuBar, 1,
"(MenuBarHandle inMbar) -> (MenuBarHandle outMbar)"},
PyDoc_STR("(MenuBarHandle inMbar) -> (MenuBarHandle outMbar)")},
#endif
#if TARGET_API_MAC_CARBON
{"DisposeMenuBar", (PyCFunction)Menu_DisposeMenuBar, 1,
"(MenuBarHandle inMbar) -> None"},
PyDoc_STR("(MenuBarHandle inMbar) -> None")},
#endif
{"GetMenuHandle", (PyCFunction)Menu_GetMenuHandle, 1,
"(MenuID menuID) -> (MenuHandle _rv)"},
PyDoc_STR("(MenuID menuID) -> (MenuHandle _rv)")},
{"MacDeleteMenu", (PyCFunction)Menu_MacDeleteMenu, 1,
"(MenuID menuID) -> None"},
PyDoc_STR("(MenuID menuID) -> None")},
{"ClearMenuBar", (PyCFunction)Menu_ClearMenuBar, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#if !TARGET_API_MAC_CARBON
{"SetMenuFlash", (PyCFunction)Menu_SetMenuFlash, 1,
"(short count) -> None"},
PyDoc_STR("(short count) -> None")},
#endif
{"SetMenuFlashCount", (PyCFunction)Menu_SetMenuFlashCount, 1,
"(short count) -> None"},
PyDoc_STR("(short count) -> None")},
{"FlashMenuBar", (PyCFunction)Menu_FlashMenuBar, 1,
"(MenuID menuID) -> None"},
PyDoc_STR("(MenuID menuID) -> None")},
#if !TARGET_API_MAC_CARBON
{"SystemEdit", (PyCFunction)Menu_SystemEdit, 1,
"(short editCmd) -> (Boolean _rv)"},
PyDoc_STR("(short editCmd) -> (Boolean _rv)")},
#endif
#if !TARGET_API_MAC_CARBON
{"SystemMenu", (PyCFunction)Menu_SystemMenu, 1,
"(long menuResult) -> None"},
PyDoc_STR("(long menuResult) -> None")},
#endif
{"IsMenuBarVisible", (PyCFunction)Menu_IsMenuBarVisible, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
{"ShowMenuBar", (PyCFunction)Menu_ShowMenuBar, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"HideMenuBar", (PyCFunction)Menu_HideMenuBar, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#if TARGET_API_MAC_CARBON
{"AcquireRootMenu", (PyCFunction)Menu_AcquireRootMenu, 1,
"() -> (MenuHandle _rv)"},
PyDoc_STR("() -> (MenuHandle _rv)")},
#endif
{"DeleteMCEntries", (PyCFunction)Menu_DeleteMCEntries, 1,
"(MenuID menuID, short menuItem) -> None"},
PyDoc_STR("(MenuID menuID, short menuItem) -> None")},
{"InitContextualMenus", (PyCFunction)Menu_InitContextualMenus, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"IsShowContextualMenuClick", (PyCFunction)Menu_IsShowContextualMenuClick, 1,
"(EventRecord inEvent) -> (Boolean _rv)"},
PyDoc_STR("(EventRecord inEvent) -> (Boolean _rv)")},
{"LMGetTheMenu", (PyCFunction)Menu_LMGetTheMenu, 1,
"() -> (SInt16 _rv)"},
PyDoc_STR("() -> (SInt16 _rv)")},
#if !TARGET_API_MAC_CARBON
{"OpenDeskAcc", (PyCFunction)Menu_OpenDeskAcc, 1,
"(Str255 name) -> None"},
PyDoc_STR("(Str255 name) -> None")},
#endif
{"as_Menu", (PyCFunction)Menu_as_Menu, 1,
"(Handle h) -> (MenuHandle _rv)"},
PyDoc_STR("(Handle h) -> (MenuHandle _rv)")},
{"GetMenu", (PyCFunction)Menu_GetMenu, 1,
"(short resourceID) -> (MenuHandle _rv)"},
PyDoc_STR("(short resourceID) -> (MenuHandle _rv)")},
{"DeleteMenu", (PyCFunction)Menu_DeleteMenu, 1,
"(short menuID) -> None"},
PyDoc_STR("(short menuID) -> None")},
{"DrawMenuBar", (PyCFunction)Menu_DrawMenuBar, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#if TARGET_API_MAC_CARBON
{"CountMenuItemsWithCommandID", (PyCFunction)Menu_CountMenuItemsWithCommandID, 1,
"(MenuHandle inMenu, MenuCommand inCommandID) -> (ItemCount _rv)"},
PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> (ItemCount _rv)")},
#endif
#if TARGET_API_MAC_CARBON
{"GetIndMenuItemWithCommandID", (PyCFunction)Menu_GetIndMenuItemWithCommandID, 1,
"(MenuHandle inMenu, MenuCommand inCommandID, UInt32 inItemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)"},
PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, UInt32 inItemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)")},
#endif
#if TARGET_API_MAC_CARBON
{"EnableMenuCommand", (PyCFunction)Menu_EnableMenuCommand, 1,
"(MenuHandle inMenu, MenuCommand inCommandID) -> None"},
PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"DisableMenuCommand", (PyCFunction)Menu_DisableMenuCommand, 1,
"(MenuHandle inMenu, MenuCommand inCommandID) -> None"},
PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"IsMenuCommandEnabled", (PyCFunction)Menu_IsMenuCommandEnabled, 1,
"(MenuHandle inMenu, MenuCommand inCommandID) -> (Boolean _rv)"},
PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> (Boolean _rv)")},
#endif
#if TARGET_API_MAC_CARBON
{"SetMenuCommandMark", (PyCFunction)Menu_SetMenuCommandMark, 1,
"(MenuHandle inMenu, MenuCommand inCommandID, UniChar inMark) -> None"},
PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, UniChar inMark) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"GetMenuCommandMark", (PyCFunction)Menu_GetMenuCommandMark, 1,
"(MenuHandle inMenu, MenuCommand inCommandID) -> (UniChar outMark)"},
PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID) -> (UniChar outMark)")},
#endif
#if TARGET_API_MAC_CARBON
{"GetMenuCommandPropertySize", (PyCFunction)Menu_GetMenuCommandPropertySize, 1,
"(MenuHandle inMenu, MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> (ByteCount outSize)"},
PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> (ByteCount outSize)")},
#endif
#if TARGET_API_MAC_CARBON
{"RemoveMenuCommandProperty", (PyCFunction)Menu_RemoveMenuCommandProperty, 1,
"(MenuHandle inMenu, MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> None"},
PyDoc_STR("(MenuHandle inMenu, MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> None")},
#endif
{NULL, NULL, 0}
};

630
Mac/Modules/qd/_Qdmodule.c
View File

@ -470,9 +470,9 @@ static PyObject *BMObj_putdata(BitMapObject *_self, PyObject *_args)
static PyMethodDef BMObj_methods[] = {
{"getdata", (PyCFunction)BMObj_getdata, 1,
"(int start, int size) -> string. Return bytes from the bitmap"},
PyDoc_STR("(int start, int size) -> string. Return bytes from the bitmap")},
{"putdata", (PyCFunction)BMObj_putdata, 1,
"(int start, string data). Store bytes into the bitmap"},
PyDoc_STR("(int start, string data). Store bytes into the bitmap")},
{NULL, NULL, 0}
};
@ -6462,664 +6462,664 @@ static PyObject *Qd_RawBitMap(PyObject *_self, PyObject *_args)
static PyMethodDef Qd_methods[] = {
{"MacSetPort", (PyCFunction)Qd_MacSetPort, 1,
"(GrafPtr port) -> None"},
PyDoc_STR("(GrafPtr port) -> None")},
{"GetPort", (PyCFunction)Qd_GetPort, 1,
"() -> (GrafPtr port)"},
PyDoc_STR("() -> (GrafPtr port)")},
{"GrafDevice", (PyCFunction)Qd_GrafDevice, 1,
"(short device) -> None"},
PyDoc_STR("(short device) -> None")},
{"SetPortBits", (PyCFunction)Qd_SetPortBits, 1,
"(BitMapPtr bm) -> None"},
PyDoc_STR("(BitMapPtr bm) -> None")},
{"PortSize", (PyCFunction)Qd_PortSize, 1,
"(short width, short height) -> None"},
PyDoc_STR("(short width, short height) -> None")},
{"MovePortTo", (PyCFunction)Qd_MovePortTo, 1,
"(short leftGlobal, short topGlobal) -> None"},
PyDoc_STR("(short leftGlobal, short topGlobal) -> None")},
{"SetOrigin", (PyCFunction)Qd_SetOrigin, 1,
"(short h, short v) -> None"},
PyDoc_STR("(short h, short v) -> None")},
{"SetClip", (PyCFunction)Qd_SetClip, 1,
"(RgnHandle rgn) -> None"},
PyDoc_STR("(RgnHandle rgn) -> None")},
{"GetClip", (PyCFunction)Qd_GetClip, 1,
"(RgnHandle rgn) -> None"},
PyDoc_STR("(RgnHandle rgn) -> None")},
{"ClipRect", (PyCFunction)Qd_ClipRect, 1,
"(Rect r) -> None"},
PyDoc_STR("(Rect r) -> None")},
{"BackPat", (PyCFunction)Qd_BackPat, 1,
"(Pattern pat) -> None"},
PyDoc_STR("(Pattern pat) -> None")},
{"InitCursor", (PyCFunction)Qd_InitCursor, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"MacSetCursor", (PyCFunction)Qd_MacSetCursor, 1,
"(Cursor crsr) -> None"},
PyDoc_STR("(Cursor crsr) -> None")},
{"HideCursor", (PyCFunction)Qd_HideCursor, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"MacShowCursor", (PyCFunction)Qd_MacShowCursor, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"ObscureCursor", (PyCFunction)Qd_ObscureCursor, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"HidePen", (PyCFunction)Qd_HidePen, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"ShowPen", (PyCFunction)Qd_ShowPen, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"GetPen", (PyCFunction)Qd_GetPen, 1,
"() -> (Point pt)"},
PyDoc_STR("() -> (Point pt)")},
{"GetPenState", (PyCFunction)Qd_GetPenState, 1,
"() -> (PenState pnState)"},
PyDoc_STR("() -> (PenState pnState)")},
{"SetPenState", (PyCFunction)Qd_SetPenState, 1,
"(PenState pnState) -> None"},
PyDoc_STR("(PenState pnState) -> None")},
{"PenSize", (PyCFunction)Qd_PenSize, 1,
"(short width, short height) -> None"},
PyDoc_STR("(short width, short height) -> None")},
{"PenMode", (PyCFunction)Qd_PenMode, 1,
"(short mode) -> None"},
PyDoc_STR("(short mode) -> None")},
{"PenPat", (PyCFunction)Qd_PenPat, 1,
"(Pattern pat) -> None"},
PyDoc_STR("(Pattern pat) -> None")},
{"PenNormal", (PyCFunction)Qd_PenNormal, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"MoveTo", (PyCFunction)Qd_MoveTo, 1,
"(short h, short v) -> None"},
PyDoc_STR("(short h, short v) -> None")},
{"Move", (PyCFunction)Qd_Move, 1,
"(short dh, short dv) -> None"},
PyDoc_STR("(short dh, short dv) -> None")},
{"MacLineTo", (PyCFunction)Qd_MacLineTo, 1,
"(short h, short v) -> None"},
PyDoc_STR("(short h, short v) -> None")},
{"Line", (PyCFunction)Qd_Line, 1,
"(short dh, short dv) -> None"},
PyDoc_STR("(short dh, short dv) -> None")},
{"ForeColor", (PyCFunction)Qd_ForeColor, 1,
"(long color) -> None"},
PyDoc_STR("(long color) -> None")},
{"BackColor", (PyCFunction)Qd_BackColor, 1,
"(long color) -> None"},
PyDoc_STR("(long color) -> None")},
{"ColorBit", (PyCFunction)Qd_ColorBit, 1,
"(short whichBit) -> None"},
PyDoc_STR("(short whichBit) -> None")},
{"MacSetRect", (PyCFunction)Qd_MacSetRect, 1,
"(short left, short top, short right, short bottom) -> (Rect r)"},
PyDoc_STR("(short left, short top, short right, short bottom) -> (Rect r)")},
{"MacOffsetRect", (PyCFunction)Qd_MacOffsetRect, 1,
"(Rect r, short dh, short dv) -> (Rect r)"},
PyDoc_STR("(Rect r, short dh, short dv) -> (Rect r)")},
{"MacInsetRect", (PyCFunction)Qd_MacInsetRect, 1,
"(Rect r, short dh, short dv) -> (Rect r)"},
PyDoc_STR("(Rect r, short dh, short dv) -> (Rect r)")},
{"SectRect", (PyCFunction)Qd_SectRect, 1,
"(Rect src1, Rect src2) -> (Boolean _rv, Rect dstRect)"},
PyDoc_STR("(Rect src1, Rect src2) -> (Boolean _rv, Rect dstRect)")},
{"MacUnionRect", (PyCFunction)Qd_MacUnionRect, 1,
"(Rect src1, Rect src2) -> (Rect dstRect)"},
PyDoc_STR("(Rect src1, Rect src2) -> (Rect dstRect)")},
{"MacEqualRect", (PyCFunction)Qd_MacEqualRect, 1,
"(Rect rect1, Rect rect2) -> (Boolean _rv)"},
PyDoc_STR("(Rect rect1, Rect rect2) -> (Boolean _rv)")},
{"EmptyRect", (PyCFunction)Qd_EmptyRect, 1,
"(Rect r) -> (Boolean _rv)"},
PyDoc_STR("(Rect r) -> (Boolean _rv)")},
{"MacFrameRect", (PyCFunction)Qd_MacFrameRect, 1,
"(Rect r) -> None"},
PyDoc_STR("(Rect r) -> None")},
{"PaintRect", (PyCFunction)Qd_PaintRect, 1,
"(Rect r) -> None"},
PyDoc_STR("(Rect r) -> None")},
{"EraseRect", (PyCFunction)Qd_EraseRect, 1,
"(Rect r) -> None"},
PyDoc_STR("(Rect r) -> None")},
{"MacInvertRect", (PyCFunction)Qd_MacInvertRect, 1,
"(Rect r) -> None"},
PyDoc_STR("(Rect r) -> None")},
{"MacFillRect", (PyCFunction)Qd_MacFillRect, 1,
"(Rect r, Pattern pat) -> None"},
PyDoc_STR("(Rect r, Pattern pat) -> None")},
{"FrameOval", (PyCFunction)Qd_FrameOval, 1,
"(Rect r) -> None"},
PyDoc_STR("(Rect r) -> None")},
{"PaintOval", (PyCFunction)Qd_PaintOval, 1,
"(Rect r) -> None"},
PyDoc_STR("(Rect r) -> None")},
{"EraseOval", (PyCFunction)Qd_EraseOval, 1,
"(Rect r) -> None"},
PyDoc_STR("(Rect r) -> None")},
{"InvertOval", (PyCFunction)Qd_InvertOval, 1,
"(Rect r) -> None"},
PyDoc_STR("(Rect r) -> None")},
{"FillOval", (PyCFunction)Qd_FillOval, 1,
"(Rect r, Pattern pat) -> None"},
PyDoc_STR("(Rect r, Pattern pat) -> None")},
{"FrameRoundRect", (PyCFunction)Qd_FrameRoundRect, 1,
"(Rect r, short ovalWidth, short ovalHeight) -> None"},
PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight) -> None")},
{"PaintRoundRect", (PyCFunction)Qd_PaintRoundRect, 1,
"(Rect r, short ovalWidth, short ovalHeight) -> None"},
PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight) -> None")},
{"EraseRoundRect", (PyCFunction)Qd_EraseRoundRect, 1,
"(Rect r, short ovalWidth, short ovalHeight) -> None"},
PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight) -> None")},
{"InvertRoundRect", (PyCFunction)Qd_InvertRoundRect, 1,
"(Rect r, short ovalWidth, short ovalHeight) -> None"},
PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight) -> None")},
{"FillRoundRect", (PyCFunction)Qd_FillRoundRect, 1,
"(Rect r, short ovalWidth, short ovalHeight, Pattern pat) -> None"},
PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight, Pattern pat) -> None")},
{"FrameArc", (PyCFunction)Qd_FrameArc, 1,
"(Rect r, short startAngle, short arcAngle) -> None"},
PyDoc_STR("(Rect r, short startAngle, short arcAngle) -> None")},
{"PaintArc", (PyCFunction)Qd_PaintArc, 1,
"(Rect r, short startAngle, short arcAngle) -> None"},
PyDoc_STR("(Rect r, short startAngle, short arcAngle) -> None")},
{"EraseArc", (PyCFunction)Qd_EraseArc, 1,
"(Rect r, short startAngle, short arcAngle) -> None"},
PyDoc_STR("(Rect r, short startAngle, short arcAngle) -> None")},
{"InvertArc", (PyCFunction)Qd_InvertArc, 1,
"(Rect r, short startAngle, short arcAngle) -> None"},
PyDoc_STR("(Rect r, short startAngle, short arcAngle) -> None")},
{"FillArc", (PyCFunction)Qd_FillArc, 1,
"(Rect r, short startAngle, short arcAngle, Pattern pat) -> None"},
PyDoc_STR("(Rect r, short startAngle, short arcAngle, Pattern pat) -> None")},
{"NewRgn", (PyCFunction)Qd_NewRgn, 1,
"() -> (RgnHandle _rv)"},
PyDoc_STR("() -> (RgnHandle _rv)")},
{"OpenRgn", (PyCFunction)Qd_OpenRgn, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CloseRgn", (PyCFunction)Qd_CloseRgn, 1,
"(RgnHandle dstRgn) -> None"},
PyDoc_STR("(RgnHandle dstRgn) -> None")},
{"BitMapToRegion", (PyCFunction)Qd_BitMapToRegion, 1,
"(RgnHandle region, BitMapPtr bMap) -> None"},
PyDoc_STR("(RgnHandle region, BitMapPtr bMap) -> None")},
#if TARGET_API_MAC_CARBON
{"RgnToHandle", (PyCFunction)Qd_RgnToHandle, 1,
"(RgnHandle region, Handle flattenedRgnDataHdl) -> None"},
PyDoc_STR("(RgnHandle region, Handle flattenedRgnDataHdl) -> None")},
#endif
{"DisposeRgn", (PyCFunction)Qd_DisposeRgn, 1,
"(RgnHandle rgn) -> None"},
PyDoc_STR("(RgnHandle rgn) -> None")},
{"MacCopyRgn", (PyCFunction)Qd_MacCopyRgn, 1,
"(RgnHandle srcRgn, RgnHandle dstRgn) -> None"},
PyDoc_STR("(RgnHandle srcRgn, RgnHandle dstRgn) -> None")},
{"SetEmptyRgn", (PyCFunction)Qd_SetEmptyRgn, 1,
"(RgnHandle rgn) -> None"},
PyDoc_STR("(RgnHandle rgn) -> None")},
{"MacSetRectRgn", (PyCFunction)Qd_MacSetRectRgn, 1,
"(RgnHandle rgn, short left, short top, short right, short bottom) -> None"},
PyDoc_STR("(RgnHandle rgn, short left, short top, short right, short bottom) -> None")},
{"RectRgn", (PyCFunction)Qd_RectRgn, 1,
"(RgnHandle rgn, Rect r) -> None"},
PyDoc_STR("(RgnHandle rgn, Rect r) -> None")},
{"MacOffsetRgn", (PyCFunction)Qd_MacOffsetRgn, 1,
"(RgnHandle rgn, short dh, short dv) -> None"},
PyDoc_STR("(RgnHandle rgn, short dh, short dv) -> None")},
{"InsetRgn", (PyCFunction)Qd_InsetRgn, 1,
"(RgnHandle rgn, short dh, short dv) -> None"},
PyDoc_STR("(RgnHandle rgn, short dh, short dv) -> None")},
{"SectRgn", (PyCFunction)Qd_SectRgn, 1,
"(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")},
{"MacUnionRgn", (PyCFunction)Qd_MacUnionRgn, 1,
"(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")},
{"DiffRgn", (PyCFunction)Qd_DiffRgn, 1,
"(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")},
{"MacXorRgn", (PyCFunction)Qd_MacXorRgn, 1,
"(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")},
{"RectInRgn", (PyCFunction)Qd_RectInRgn, 1,
"(Rect r, RgnHandle rgn) -> (Boolean _rv)"},
PyDoc_STR("(Rect r, RgnHandle rgn) -> (Boolean _rv)")},
{"MacEqualRgn", (PyCFunction)Qd_MacEqualRgn, 1,
"(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)"},
PyDoc_STR("(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)")},
{"EmptyRgn", (PyCFunction)Qd_EmptyRgn, 1,
"(RgnHandle rgn) -> (Boolean _rv)"},
PyDoc_STR("(RgnHandle rgn) -> (Boolean _rv)")},
{"MacFrameRgn", (PyCFunction)Qd_MacFrameRgn, 1,
"(RgnHandle rgn) -> None"},
PyDoc_STR("(RgnHandle rgn) -> None")},
{"MacPaintRgn", (PyCFunction)Qd_MacPaintRgn, 1,
"(RgnHandle rgn) -> None"},
PyDoc_STR("(RgnHandle rgn) -> None")},
{"EraseRgn", (PyCFunction)Qd_EraseRgn, 1,
"(RgnHandle rgn) -> None"},
PyDoc_STR("(RgnHandle rgn) -> None")},
{"MacInvertRgn", (PyCFunction)Qd_MacInvertRgn, 1,
"(RgnHandle rgn) -> None"},
PyDoc_STR("(RgnHandle rgn) -> None")},
{"MacFillRgn", (PyCFunction)Qd_MacFillRgn, 1,
"(RgnHandle rgn, Pattern pat) -> None"},
PyDoc_STR("(RgnHandle rgn, Pattern pat) -> None")},
{"ScrollRect", (PyCFunction)Qd_ScrollRect, 1,
"(Rect r, short dh, short dv, RgnHandle updateRgn) -> None"},
PyDoc_STR("(Rect r, short dh, short dv, RgnHandle updateRgn) -> None")},
{"CopyBits", (PyCFunction)Qd_CopyBits, 1,
"(BitMapPtr srcBits, BitMapPtr dstBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"},
PyDoc_STR("(BitMapPtr srcBits, BitMapPtr dstBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None")},
{"CopyMask", (PyCFunction)Qd_CopyMask, 1,
"(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect) -> None"},
PyDoc_STR("(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect) -> None")},
{"OpenPicture", (PyCFunction)Qd_OpenPicture, 1,
"(Rect picFrame) -> (PicHandle _rv)"},
PyDoc_STR("(Rect picFrame) -> (PicHandle _rv)")},
{"PicComment", (PyCFunction)Qd_PicComment, 1,
"(short kind, short dataSize, Handle dataHandle) -> None"},
PyDoc_STR("(short kind, short dataSize, Handle dataHandle) -> None")},
{"ClosePicture", (PyCFunction)Qd_ClosePicture, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"DrawPicture", (PyCFunction)Qd_DrawPicture, 1,
"(PicHandle myPicture, Rect dstRect) -> None"},
PyDoc_STR("(PicHandle myPicture, Rect dstRect) -> None")},
{"KillPicture", (PyCFunction)Qd_KillPicture, 1,
"(PicHandle myPicture) -> None"},
PyDoc_STR("(PicHandle myPicture) -> None")},
{"OpenPoly", (PyCFunction)Qd_OpenPoly, 1,
"() -> (PolyHandle _rv)"},
PyDoc_STR("() -> (PolyHandle _rv)")},
{"ClosePoly", (PyCFunction)Qd_ClosePoly, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"KillPoly", (PyCFunction)Qd_KillPoly, 1,
"(PolyHandle poly) -> None"},
PyDoc_STR("(PolyHandle poly) -> None")},
{"OffsetPoly", (PyCFunction)Qd_OffsetPoly, 1,
"(PolyHandle poly, short dh, short dv) -> None"},
PyDoc_STR("(PolyHandle poly, short dh, short dv) -> None")},
{"FramePoly", (PyCFunction)Qd_FramePoly, 1,
"(PolyHandle poly) -> None"},
PyDoc_STR("(PolyHandle poly) -> None")},
{"PaintPoly", (PyCFunction)Qd_PaintPoly, 1,
"(PolyHandle poly) -> None"},
PyDoc_STR("(PolyHandle poly) -> None")},
{"ErasePoly", (PyCFunction)Qd_ErasePoly, 1,
"(PolyHandle poly) -> None"},
PyDoc_STR("(PolyHandle poly) -> None")},
{"InvertPoly", (PyCFunction)Qd_InvertPoly, 1,
"(PolyHandle poly) -> None"},
PyDoc_STR("(PolyHandle poly) -> None")},
{"FillPoly", (PyCFunction)Qd_FillPoly, 1,
"(PolyHandle poly, Pattern pat) -> None"},
PyDoc_STR("(PolyHandle poly, Pattern pat) -> None")},
{"SetPt", (PyCFunction)Qd_SetPt, 1,
"(short h, short v) -> (Point pt)"},
PyDoc_STR("(short h, short v) -> (Point pt)")},
{"LocalToGlobal", (PyCFunction)Qd_LocalToGlobal, 1,
"(Point pt) -> (Point pt)"},
PyDoc_STR("(Point pt) -> (Point pt)")},
{"GlobalToLocal", (PyCFunction)Qd_GlobalToLocal, 1,
"(Point pt) -> (Point pt)"},
PyDoc_STR("(Point pt) -> (Point pt)")},
{"Random", (PyCFunction)Qd_Random, 1,
"() -> (short _rv)"},
PyDoc_STR("() -> (short _rv)")},
{"MacGetPixel", (PyCFunction)Qd_MacGetPixel, 1,
"(short h, short v) -> (Boolean _rv)"},
PyDoc_STR("(short h, short v) -> (Boolean _rv)")},
{"ScalePt", (PyCFunction)Qd_ScalePt, 1,
"(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)"},
PyDoc_STR("(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)")},
{"MapPt", (PyCFunction)Qd_MapPt, 1,
"(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)"},
PyDoc_STR("(Point pt, Rect srcRect, Rect dstRect) -> (Point pt)")},
{"MapRect", (PyCFunction)Qd_MapRect, 1,
"(Rect r, Rect srcRect, Rect dstRect) -> (Rect r)"},
PyDoc_STR("(Rect r, Rect srcRect, Rect dstRect) -> (Rect r)")},
{"MapRgn", (PyCFunction)Qd_MapRgn, 1,
"(RgnHandle rgn, Rect srcRect, Rect dstRect) -> None"},
PyDoc_STR("(RgnHandle rgn, Rect srcRect, Rect dstRect) -> None")},
{"MapPoly", (PyCFunction)Qd_MapPoly, 1,
"(PolyHandle poly, Rect srcRect, Rect dstRect) -> None"},
PyDoc_STR("(PolyHandle poly, Rect srcRect, Rect dstRect) -> None")},
{"StdBits", (PyCFunction)Qd_StdBits, 1,
"(BitMapPtr srcBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"},
PyDoc_STR("(BitMapPtr srcBits, Rect srcRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None")},
{"AddPt", (PyCFunction)Qd_AddPt, 1,
"(Point src, Point dst) -> (Point dst)"},
PyDoc_STR("(Point src, Point dst) -> (Point dst)")},
{"EqualPt", (PyCFunction)Qd_EqualPt, 1,
"(Point pt1, Point pt2) -> (Boolean _rv)"},
PyDoc_STR("(Point pt1, Point pt2) -> (Boolean _rv)")},
{"MacPtInRect", (PyCFunction)Qd_MacPtInRect, 1,
"(Point pt, Rect r) -> (Boolean _rv)"},
PyDoc_STR("(Point pt, Rect r) -> (Boolean _rv)")},
{"Pt2Rect", (PyCFunction)Qd_Pt2Rect, 1,
"(Point pt1, Point pt2) -> (Rect dstRect)"},
PyDoc_STR("(Point pt1, Point pt2) -> (Rect dstRect)")},
{"PtToAngle", (PyCFunction)Qd_PtToAngle, 1,
"(Rect r, Point pt) -> (short angle)"},
PyDoc_STR("(Rect r, Point pt) -> (short angle)")},
{"SubPt", (PyCFunction)Qd_SubPt, 1,
"(Point src, Point dst) -> (Point dst)"},
PyDoc_STR("(Point src, Point dst) -> (Point dst)")},
{"PtInRgn", (PyCFunction)Qd_PtInRgn, 1,
"(Point pt, RgnHandle rgn) -> (Boolean _rv)"},
PyDoc_STR("(Point pt, RgnHandle rgn) -> (Boolean _rv)")},
{"NewPixMap", (PyCFunction)Qd_NewPixMap, 1,
"() -> (PixMapHandle _rv)"},
PyDoc_STR("() -> (PixMapHandle _rv)")},
{"DisposePixMap", (PyCFunction)Qd_DisposePixMap, 1,
"(PixMapHandle pm) -> None"},
PyDoc_STR("(PixMapHandle pm) -> None")},
{"CopyPixMap", (PyCFunction)Qd_CopyPixMap, 1,
"(PixMapHandle srcPM, PixMapHandle dstPM) -> None"},
PyDoc_STR("(PixMapHandle srcPM, PixMapHandle dstPM) -> None")},
{"NewPixPat", (PyCFunction)Qd_NewPixPat, 1,
"() -> (PixPatHandle _rv)"},
PyDoc_STR("() -> (PixPatHandle _rv)")},
{"DisposePixPat", (PyCFunction)Qd_DisposePixPat, 1,
"(PixPatHandle pp) -> None"},
PyDoc_STR("(PixPatHandle pp) -> None")},
{"CopyPixPat", (PyCFunction)Qd_CopyPixPat, 1,
"(PixPatHandle srcPP, PixPatHandle dstPP) -> None"},
PyDoc_STR("(PixPatHandle srcPP, PixPatHandle dstPP) -> None")},
{"PenPixPat", (PyCFunction)Qd_PenPixPat, 1,
"(PixPatHandle pp) -> None"},
PyDoc_STR("(PixPatHandle pp) -> None")},
{"BackPixPat", (PyCFunction)Qd_BackPixPat, 1,
"(PixPatHandle pp) -> None"},
PyDoc_STR("(PixPatHandle pp) -> None")},
{"GetPixPat", (PyCFunction)Qd_GetPixPat, 1,
"(short patID) -> (PixPatHandle _rv)"},
PyDoc_STR("(short patID) -> (PixPatHandle _rv)")},
{"MakeRGBPat", (PyCFunction)Qd_MakeRGBPat, 1,
"(PixPatHandle pp, RGBColor myColor) -> None"},
PyDoc_STR("(PixPatHandle pp, RGBColor myColor) -> None")},
{"FillCRect", (PyCFunction)Qd_FillCRect, 1,
"(Rect r, PixPatHandle pp) -> None"},
PyDoc_STR("(Rect r, PixPatHandle pp) -> None")},
{"FillCOval", (PyCFunction)Qd_FillCOval, 1,
"(Rect r, PixPatHandle pp) -> None"},
PyDoc_STR("(Rect r, PixPatHandle pp) -> None")},
{"FillCRoundRect", (PyCFunction)Qd_FillCRoundRect, 1,
"(Rect r, short ovalWidth, short ovalHeight, PixPatHandle pp) -> None"},
PyDoc_STR("(Rect r, short ovalWidth, short ovalHeight, PixPatHandle pp) -> None")},
{"FillCArc", (PyCFunction)Qd_FillCArc, 1,
"(Rect r, short startAngle, short arcAngle, PixPatHandle pp) -> None"},
PyDoc_STR("(Rect r, short startAngle, short arcAngle, PixPatHandle pp) -> None")},
{"FillCRgn", (PyCFunction)Qd_FillCRgn, 1,
"(RgnHandle rgn, PixPatHandle pp) -> None"},
PyDoc_STR("(RgnHandle rgn, PixPatHandle pp) -> None")},
{"FillCPoly", (PyCFunction)Qd_FillCPoly, 1,
"(PolyHandle poly, PixPatHandle pp) -> None"},
PyDoc_STR("(PolyHandle poly, PixPatHandle pp) -> None")},
{"RGBForeColor", (PyCFunction)Qd_RGBForeColor, 1,
"(RGBColor color) -> None"},
PyDoc_STR("(RGBColor color) -> None")},
{"RGBBackColor", (PyCFunction)Qd_RGBBackColor, 1,
"(RGBColor color) -> None"},
PyDoc_STR("(RGBColor color) -> None")},
{"SetCPixel", (PyCFunction)Qd_SetCPixel, 1,
"(short h, short v, RGBColor cPix) -> None"},
PyDoc_STR("(short h, short v, RGBColor cPix) -> None")},
{"SetPortPix", (PyCFunction)Qd_SetPortPix, 1,
"(PixMapHandle pm) -> None"},
PyDoc_STR("(PixMapHandle pm) -> None")},
{"GetCPixel", (PyCFunction)Qd_GetCPixel, 1,
"(short h, short v) -> (RGBColor cPix)"},
PyDoc_STR("(short h, short v) -> (RGBColor cPix)")},
{"GetForeColor", (PyCFunction)Qd_GetForeColor, 1,
"() -> (RGBColor color)"},
PyDoc_STR("() -> (RGBColor color)")},
{"GetBackColor", (PyCFunction)Qd_GetBackColor, 1,
"() -> (RGBColor color)"},
PyDoc_STR("() -> (RGBColor color)")},
{"OpColor", (PyCFunction)Qd_OpColor, 1,
"(RGBColor color) -> None"},
PyDoc_STR("(RGBColor color) -> None")},
{"HiliteColor", (PyCFunction)Qd_HiliteColor, 1,
"(RGBColor color) -> None"},
PyDoc_STR("(RGBColor color) -> None")},
{"DisposeCTable", (PyCFunction)Qd_DisposeCTable, 1,
"(CTabHandle cTable) -> None"},
PyDoc_STR("(CTabHandle cTable) -> None")},
{"GetCTable", (PyCFunction)Qd_GetCTable, 1,
"(short ctID) -> (CTabHandle _rv)"},
PyDoc_STR("(short ctID) -> (CTabHandle _rv)")},
{"GetCCursor", (PyCFunction)Qd_GetCCursor, 1,
"(short crsrID) -> (CCrsrHandle _rv)"},
PyDoc_STR("(short crsrID) -> (CCrsrHandle _rv)")},
{"SetCCursor", (PyCFunction)Qd_SetCCursor, 1,
"(CCrsrHandle cCrsr) -> None"},
PyDoc_STR("(CCrsrHandle cCrsr) -> None")},
{"AllocCursor", (PyCFunction)Qd_AllocCursor, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"DisposeCCursor", (PyCFunction)Qd_DisposeCCursor, 1,
"(CCrsrHandle cCrsr) -> None"},
PyDoc_STR("(CCrsrHandle cCrsr) -> None")},
{"GetMaxDevice", (PyCFunction)Qd_GetMaxDevice, 1,
"(Rect globalRect) -> (GDHandle _rv)"},
PyDoc_STR("(Rect globalRect) -> (GDHandle _rv)")},
{"GetCTSeed", (PyCFunction)Qd_GetCTSeed, 1,
"() -> (long _rv)"},
PyDoc_STR("() -> (long _rv)")},
{"GetDeviceList", (PyCFunction)Qd_GetDeviceList, 1,
"() -> (GDHandle _rv)"},
PyDoc_STR("() -> (GDHandle _rv)")},
{"GetMainDevice", (PyCFunction)Qd_GetMainDevice, 1,
"() -> (GDHandle _rv)"},
PyDoc_STR("() -> (GDHandle _rv)")},
{"GetNextDevice", (PyCFunction)Qd_GetNextDevice, 1,
"(GDHandle curDevice) -> (GDHandle _rv)"},
PyDoc_STR("(GDHandle curDevice) -> (GDHandle _rv)")},
{"TestDeviceAttribute", (PyCFunction)Qd_TestDeviceAttribute, 1,
"(GDHandle gdh, short attribute) -> (Boolean _rv)"},
PyDoc_STR("(GDHandle gdh, short attribute) -> (Boolean _rv)")},
{"SetDeviceAttribute", (PyCFunction)Qd_SetDeviceAttribute, 1,
"(GDHandle gdh, short attribute, Boolean value) -> None"},
PyDoc_STR("(GDHandle gdh, short attribute, Boolean value) -> None")},
{"InitGDevice", (PyCFunction)Qd_InitGDevice, 1,
"(short qdRefNum, long mode, GDHandle gdh) -> None"},
PyDoc_STR("(short qdRefNum, long mode, GDHandle gdh) -> None")},
{"NewGDevice", (PyCFunction)Qd_NewGDevice, 1,
"(short refNum, long mode) -> (GDHandle _rv)"},
PyDoc_STR("(short refNum, long mode) -> (GDHandle _rv)")},
{"DisposeGDevice", (PyCFunction)Qd_DisposeGDevice, 1,
"(GDHandle gdh) -> None"},
PyDoc_STR("(GDHandle gdh) -> None")},
{"SetGDevice", (PyCFunction)Qd_SetGDevice, 1,
"(GDHandle gd) -> None"},
PyDoc_STR("(GDHandle gd) -> None")},
{"GetGDevice", (PyCFunction)Qd_GetGDevice, 1,
"() -> (GDHandle _rv)"},
PyDoc_STR("() -> (GDHandle _rv)")},
{"Color2Index", (PyCFunction)Qd_Color2Index, 1,
"(RGBColor myColor) -> (long _rv)"},
PyDoc_STR("(RGBColor myColor) -> (long _rv)")},
{"Index2Color", (PyCFunction)Qd_Index2Color, 1,
"(long index) -> (RGBColor aColor)"},
PyDoc_STR("(long index) -> (RGBColor aColor)")},
{"InvertColor", (PyCFunction)Qd_InvertColor, 1,
"() -> (RGBColor myColor)"},
PyDoc_STR("() -> (RGBColor myColor)")},
{"RealColor", (PyCFunction)Qd_RealColor, 1,
"(RGBColor color) -> (Boolean _rv)"},
PyDoc_STR("(RGBColor color) -> (Boolean _rv)")},
{"GetSubTable", (PyCFunction)Qd_GetSubTable, 1,
"(CTabHandle myColors, short iTabRes, CTabHandle targetTbl) -> None"},
PyDoc_STR("(CTabHandle myColors, short iTabRes, CTabHandle targetTbl) -> None")},
{"MakeITable", (PyCFunction)Qd_MakeITable, 1,
"(CTabHandle cTabH, ITabHandle iTabH, short res) -> None"},
PyDoc_STR("(CTabHandle cTabH, ITabHandle iTabH, short res) -> None")},
{"SetClientID", (PyCFunction)Qd_SetClientID, 1,
"(short id) -> None"},
PyDoc_STR("(short id) -> None")},
{"ProtectEntry", (PyCFunction)Qd_ProtectEntry, 1,
"(short index, Boolean protect) -> None"},
PyDoc_STR("(short index, Boolean protect) -> None")},
{"ReserveEntry", (PyCFunction)Qd_ReserveEntry, 1,
"(short index, Boolean reserve) -> None"},
PyDoc_STR("(short index, Boolean reserve) -> None")},
{"QDError", (PyCFunction)Qd_QDError, 1,
"() -> (short _rv)"},
PyDoc_STR("() -> (short _rv)")},
{"CopyDeepMask", (PyCFunction)Qd_CopyDeepMask, 1,
"(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None"},
PyDoc_STR("(BitMapPtr srcBits, BitMapPtr maskBits, BitMapPtr dstBits, Rect srcRect, Rect maskRect, Rect dstRect, short mode, RgnHandle maskRgn) -> None")},
{"GetPattern", (PyCFunction)Qd_GetPattern, 1,
"(short patternID) -> (PatHandle _rv)"},
PyDoc_STR("(short patternID) -> (PatHandle _rv)")},
{"MacGetCursor", (PyCFunction)Qd_MacGetCursor, 1,
"(short cursorID) -> (CursHandle _rv)"},
PyDoc_STR("(short cursorID) -> (CursHandle _rv)")},
{"GetPicture", (PyCFunction)Qd_GetPicture, 1,
"(short pictureID) -> (PicHandle _rv)"},
PyDoc_STR("(short pictureID) -> (PicHandle _rv)")},
{"DeltaPoint", (PyCFunction)Qd_DeltaPoint, 1,
"(Point ptA, Point ptB) -> (long _rv)"},
PyDoc_STR("(Point ptA, Point ptB) -> (long _rv)")},
{"ShieldCursor", (PyCFunction)Qd_ShieldCursor, 1,
"(Rect shieldRect, Point offsetPt) -> None"},
PyDoc_STR("(Rect shieldRect, Point offsetPt) -> None")},
{"ScreenRes", (PyCFunction)Qd_ScreenRes, 1,
"() -> (short scrnHRes, short scrnVRes)"},
PyDoc_STR("() -> (short scrnHRes, short scrnVRes)")},
{"GetIndPattern", (PyCFunction)Qd_GetIndPattern, 1,
"(short patternListID, short index) -> (Pattern thePat)"},
PyDoc_STR("(short patternListID, short index) -> (Pattern thePat)")},
{"SlopeFromAngle", (PyCFunction)Qd_SlopeFromAngle, 1,
"(short angle) -> (Fixed _rv)"},
PyDoc_STR("(short angle) -> (Fixed _rv)")},
{"AngleFromSlope", (PyCFunction)Qd_AngleFromSlope, 1,
"(Fixed slope) -> (short _rv)"},
PyDoc_STR("(Fixed slope) -> (short _rv)")},
#if TARGET_API_MAC_CARBON
{"IsValidPort", (PyCFunction)Qd_IsValidPort, 1,
"(CGrafPtr port) -> (Boolean _rv)"},
PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
#endif
{"GetPortPixMap", (PyCFunction)Qd_GetPortPixMap, 1,
"(CGrafPtr port) -> (PixMapHandle _rv)"},
PyDoc_STR("(CGrafPtr port) -> (PixMapHandle _rv)")},
{"GetPortBitMapForCopyBits", (PyCFunction)Qd_GetPortBitMapForCopyBits, 1,
"(CGrafPtr port) -> (const BitMap * _rv)"},
PyDoc_STR("(CGrafPtr port) -> (const BitMap * _rv)")},
{"GetPortBounds", (PyCFunction)Qd_GetPortBounds, 1,
"(CGrafPtr port) -> (Rect rect)"},
PyDoc_STR("(CGrafPtr port) -> (Rect rect)")},
{"GetPortForeColor", (PyCFunction)Qd_GetPortForeColor, 1,
"(CGrafPtr port) -> (RGBColor foreColor)"},
PyDoc_STR("(CGrafPtr port) -> (RGBColor foreColor)")},
{"GetPortBackColor", (PyCFunction)Qd_GetPortBackColor, 1,
"(CGrafPtr port) -> (RGBColor backColor)"},
PyDoc_STR("(CGrafPtr port) -> (RGBColor backColor)")},
{"GetPortOpColor", (PyCFunction)Qd_GetPortOpColor, 1,
"(CGrafPtr port) -> (RGBColor opColor)"},
PyDoc_STR("(CGrafPtr port) -> (RGBColor opColor)")},
{"GetPortHiliteColor", (PyCFunction)Qd_GetPortHiliteColor, 1,
"(CGrafPtr port) -> (RGBColor hiliteColor)"},
PyDoc_STR("(CGrafPtr port) -> (RGBColor hiliteColor)")},
{"GetPortTextFont", (PyCFunction)Qd_GetPortTextFont, 1,
"(CGrafPtr port) -> (short _rv)"},
PyDoc_STR("(CGrafPtr port) -> (short _rv)")},
{"GetPortTextFace", (PyCFunction)Qd_GetPortTextFace, 1,
"(CGrafPtr port) -> (Style _rv)"},
PyDoc_STR("(CGrafPtr port) -> (Style _rv)")},
{"GetPortTextMode", (PyCFunction)Qd_GetPortTextMode, 1,
"(CGrafPtr port) -> (short _rv)"},
PyDoc_STR("(CGrafPtr port) -> (short _rv)")},
{"GetPortTextSize", (PyCFunction)Qd_GetPortTextSize, 1,
"(CGrafPtr port) -> (short _rv)"},
PyDoc_STR("(CGrafPtr port) -> (short _rv)")},
{"GetPortChExtra", (PyCFunction)Qd_GetPortChExtra, 1,
"(CGrafPtr port) -> (short _rv)"},
PyDoc_STR("(CGrafPtr port) -> (short _rv)")},
{"GetPortFracHPenLocation", (PyCFunction)Qd_GetPortFracHPenLocation, 1,
"(CGrafPtr port) -> (short _rv)"},
PyDoc_STR("(CGrafPtr port) -> (short _rv)")},
{"GetPortSpExtra", (PyCFunction)Qd_GetPortSpExtra, 1,
"(CGrafPtr port) -> (Fixed _rv)"},
PyDoc_STR("(CGrafPtr port) -> (Fixed _rv)")},
{"GetPortPenVisibility", (PyCFunction)Qd_GetPortPenVisibility, 1,
"(CGrafPtr port) -> (short _rv)"},
PyDoc_STR("(CGrafPtr port) -> (short _rv)")},
{"GetPortVisibleRegion", (PyCFunction)Qd_GetPortVisibleRegion, 1,
"(CGrafPtr port, RgnHandle visRgn) -> (RgnHandle _rv)"},
PyDoc_STR("(CGrafPtr port, RgnHandle visRgn) -> (RgnHandle _rv)")},
{"GetPortClipRegion", (PyCFunction)Qd_GetPortClipRegion, 1,
"(CGrafPtr port, RgnHandle clipRgn) -> (RgnHandle _rv)"},
PyDoc_STR("(CGrafPtr port, RgnHandle clipRgn) -> (RgnHandle _rv)")},
{"GetPortBackPixPat", (PyCFunction)Qd_GetPortBackPixPat, 1,
"(CGrafPtr port, PixPatHandle backPattern) -> (PixPatHandle _rv)"},
PyDoc_STR("(CGrafPtr port, PixPatHandle backPattern) -> (PixPatHandle _rv)")},
{"GetPortPenPixPat", (PyCFunction)Qd_GetPortPenPixPat, 1,
"(CGrafPtr port, PixPatHandle penPattern) -> (PixPatHandle _rv)"},
PyDoc_STR("(CGrafPtr port, PixPatHandle penPattern) -> (PixPatHandle _rv)")},
{"GetPortFillPixPat", (PyCFunction)Qd_GetPortFillPixPat, 1,
"(CGrafPtr port, PixPatHandle fillPattern) -> (PixPatHandle _rv)"},
PyDoc_STR("(CGrafPtr port, PixPatHandle fillPattern) -> (PixPatHandle _rv)")},
{"GetPortPenSize", (PyCFunction)Qd_GetPortPenSize, 1,
"(CGrafPtr port, Point penSize) -> (Point penSize)"},
PyDoc_STR("(CGrafPtr port, Point penSize) -> (Point penSize)")},
{"GetPortPenMode", (PyCFunction)Qd_GetPortPenMode, 1,
"(CGrafPtr port) -> (SInt32 _rv)"},
PyDoc_STR("(CGrafPtr port) -> (SInt32 _rv)")},
{"GetPortPenLocation", (PyCFunction)Qd_GetPortPenLocation, 1,
"(CGrafPtr port, Point penLocation) -> (Point penLocation)"},
PyDoc_STR("(CGrafPtr port, Point penLocation) -> (Point penLocation)")},
{"IsPortRegionBeingDefined", (PyCFunction)Qd_IsPortRegionBeingDefined, 1,
"(CGrafPtr port) -> (Boolean _rv)"},
PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
{"IsPortPictureBeingDefined", (PyCFunction)Qd_IsPortPictureBeingDefined, 1,
"(CGrafPtr port) -> (Boolean _rv)"},
PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
#if TARGET_API_MAC_CARBON
{"IsPortPolyBeingDefined", (PyCFunction)Qd_IsPortPolyBeingDefined, 1,
"(CGrafPtr port) -> (Boolean _rv)"},
PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
#endif
#if TARGET_API_MAC_CARBON
{"IsPortOffscreen", (PyCFunction)Qd_IsPortOffscreen, 1,
"(CGrafPtr port) -> (Boolean _rv)"},
PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
#endif
#if TARGET_API_MAC_CARBON
{"IsPortColor", (PyCFunction)Qd_IsPortColor, 1,
"(CGrafPtr port) -> (Boolean _rv)"},
PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
#endif
{"SetPortBounds", (PyCFunction)Qd_SetPortBounds, 1,
"(CGrafPtr port, Rect rect) -> None"},
PyDoc_STR("(CGrafPtr port, Rect rect) -> None")},
{"SetPortOpColor", (PyCFunction)Qd_SetPortOpColor, 1,
"(CGrafPtr port, RGBColor opColor) -> None"},
PyDoc_STR("(CGrafPtr port, RGBColor opColor) -> None")},
{"SetPortVisibleRegion", (PyCFunction)Qd_SetPortVisibleRegion, 1,
"(CGrafPtr port, RgnHandle visRgn) -> None"},
PyDoc_STR("(CGrafPtr port, RgnHandle visRgn) -> None")},
{"SetPortClipRegion", (PyCFunction)Qd_SetPortClipRegion, 1,
"(CGrafPtr port, RgnHandle clipRgn) -> None"},
PyDoc_STR("(CGrafPtr port, RgnHandle clipRgn) -> None")},
{"SetPortPenPixPat", (PyCFunction)Qd_SetPortPenPixPat, 1,
"(CGrafPtr port, PixPatHandle penPattern) -> None"},
PyDoc_STR("(CGrafPtr port, PixPatHandle penPattern) -> None")},
{"SetPortFillPixPat", (PyCFunction)Qd_SetPortFillPixPat, 1,
"(CGrafPtr port, PixPatHandle penPattern) -> None"},
PyDoc_STR("(CGrafPtr port, PixPatHandle penPattern) -> None")},
{"SetPortBackPixPat", (PyCFunction)Qd_SetPortBackPixPat, 1,
"(CGrafPtr port, PixPatHandle backPattern) -> None"},
PyDoc_STR("(CGrafPtr port, PixPatHandle backPattern) -> None")},
{"SetPortPenSize", (PyCFunction)Qd_SetPortPenSize, 1,
"(CGrafPtr port, Point penSize) -> None"},
PyDoc_STR("(CGrafPtr port, Point penSize) -> None")},
{"SetPortPenMode", (PyCFunction)Qd_SetPortPenMode, 1,
"(CGrafPtr port, SInt32 penMode) -> None"},
PyDoc_STR("(CGrafPtr port, SInt32 penMode) -> None")},
{"SetPortFracHPenLocation", (PyCFunction)Qd_SetPortFracHPenLocation, 1,
"(CGrafPtr port, short pnLocHFrac) -> None"},
PyDoc_STR("(CGrafPtr port, short pnLocHFrac) -> None")},
{"GetPixBounds", (PyCFunction)Qd_GetPixBounds, 1,
"(PixMapHandle pixMap) -> (Rect bounds)"},
PyDoc_STR("(PixMapHandle pixMap) -> (Rect bounds)")},
{"GetPixDepth", (PyCFunction)Qd_GetPixDepth, 1,
"(PixMapHandle pixMap) -> (short _rv)"},
PyDoc_STR("(PixMapHandle pixMap) -> (short _rv)")},
{"GetQDGlobalsRandomSeed", (PyCFunction)Qd_GetQDGlobalsRandomSeed, 1,
"() -> (long _rv)"},
PyDoc_STR("() -> (long _rv)")},
{"GetQDGlobalsScreenBits", (PyCFunction)Qd_GetQDGlobalsScreenBits, 1,
"() -> (BitMap screenBits)"},
PyDoc_STR("() -> (BitMap screenBits)")},
{"GetQDGlobalsArrow", (PyCFunction)Qd_GetQDGlobalsArrow, 1,
"() -> (Cursor arrow)"},
PyDoc_STR("() -> (Cursor arrow)")},
{"GetQDGlobalsDarkGray", (PyCFunction)Qd_GetQDGlobalsDarkGray, 1,
"() -> (Pattern dkGray)"},
PyDoc_STR("() -> (Pattern dkGray)")},
{"GetQDGlobalsLightGray", (PyCFunction)Qd_GetQDGlobalsLightGray, 1,
"() -> (Pattern ltGray)"},
PyDoc_STR("() -> (Pattern ltGray)")},
{"GetQDGlobalsGray", (PyCFunction)Qd_GetQDGlobalsGray, 1,
"() -> (Pattern gray)"},
PyDoc_STR("() -> (Pattern gray)")},
{"GetQDGlobalsBlack", (PyCFunction)Qd_GetQDGlobalsBlack, 1,
"() -> (Pattern black)"},
PyDoc_STR("() -> (Pattern black)")},
{"GetQDGlobalsWhite", (PyCFunction)Qd_GetQDGlobalsWhite, 1,
"() -> (Pattern white)"},
PyDoc_STR("() -> (Pattern white)")},
{"GetQDGlobalsThePort", (PyCFunction)Qd_GetQDGlobalsThePort, 1,
"() -> (CGrafPtr _rv)"},
PyDoc_STR("() -> (CGrafPtr _rv)")},
{"SetQDGlobalsRandomSeed", (PyCFunction)Qd_SetQDGlobalsRandomSeed, 1,
"(long randomSeed) -> None"},
PyDoc_STR("(long randomSeed) -> None")},
{"SetQDGlobalsArrow", (PyCFunction)Qd_SetQDGlobalsArrow, 1,
"(Cursor arrow) -> None"},
PyDoc_STR("(Cursor arrow) -> None")},
{"GetRegionBounds", (PyCFunction)Qd_GetRegionBounds, 1,
"(RgnHandle region) -> (Rect bounds)"},
PyDoc_STR("(RgnHandle region) -> (Rect bounds)")},
#if TARGET_API_MAC_CARBON
{"IsRegionRectangular", (PyCFunction)Qd_IsRegionRectangular, 1,
"(RgnHandle region) -> (Boolean _rv)"},
PyDoc_STR("(RgnHandle region) -> (Boolean _rv)")},
#endif
#if TARGET_API_MAC_CARBON
{"CreateNewPort", (PyCFunction)Qd_CreateNewPort, 1,
"() -> (CGrafPtr _rv)"},
PyDoc_STR("() -> (CGrafPtr _rv)")},
#endif
#if TARGET_API_MAC_CARBON
{"DisposePort", (PyCFunction)Qd_DisposePort, 1,
"(CGrafPtr port) -> None"},
PyDoc_STR("(CGrafPtr port) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"SetQDError", (PyCFunction)Qd_SetQDError, 1,
"(OSErr err) -> None"},
PyDoc_STR("(OSErr err) -> None")},
#endif
{"QDIsPortBuffered", (PyCFunction)Qd_QDIsPortBuffered, 1,
"(CGrafPtr port) -> (Boolean _rv)"},
PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
{"QDIsPortBufferDirty", (PyCFunction)Qd_QDIsPortBufferDirty, 1,
"(CGrafPtr port) -> (Boolean _rv)"},
PyDoc_STR("(CGrafPtr port) -> (Boolean _rv)")},
{"QDFlushPortBuffer", (PyCFunction)Qd_QDFlushPortBuffer, 1,
"(CGrafPtr port, RgnHandle region) -> None"},
PyDoc_STR("(CGrafPtr port, RgnHandle region) -> None")},
#if TARGET_API_MAC_CARBON
{"QDGetDirtyRegion", (PyCFunction)Qd_QDGetDirtyRegion, 1,
"(CGrafPtr port, RgnHandle rgn) -> None"},
PyDoc_STR("(CGrafPtr port, RgnHandle rgn) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"QDSetDirtyRegion", (PyCFunction)Qd_QDSetDirtyRegion, 1,
"(CGrafPtr port, RgnHandle rgn) -> None"},
PyDoc_STR("(CGrafPtr port, RgnHandle rgn) -> None")},
#endif
{"LMGetScrVRes", (PyCFunction)Qd_LMGetScrVRes, 1,
"() -> (SInt16 _rv)"},
PyDoc_STR("() -> (SInt16 _rv)")},
{"LMSetScrVRes", (PyCFunction)Qd_LMSetScrVRes, 1,
"(SInt16 value) -> None"},
PyDoc_STR("(SInt16 value) -> None")},
{"LMGetScrHRes", (PyCFunction)Qd_LMGetScrHRes, 1,
"() -> (SInt16 _rv)"},
PyDoc_STR("() -> (SInt16 _rv)")},
{"LMSetScrHRes", (PyCFunction)Qd_LMSetScrHRes, 1,
"(SInt16 value) -> None"},
PyDoc_STR("(SInt16 value) -> None")},
{"LMGetMainDevice", (PyCFunction)Qd_LMGetMainDevice, 1,
"() -> (GDHandle _rv)"},
PyDoc_STR("() -> (GDHandle _rv)")},
{"LMSetMainDevice", (PyCFunction)Qd_LMSetMainDevice, 1,
"(GDHandle value) -> None"},
PyDoc_STR("(GDHandle value) -> None")},
{"LMGetDeviceList", (PyCFunction)Qd_LMGetDeviceList, 1,
"() -> (GDHandle _rv)"},
PyDoc_STR("() -> (GDHandle _rv)")},
{"LMSetDeviceList", (PyCFunction)Qd_LMSetDeviceList, 1,
"(GDHandle value) -> None"},
PyDoc_STR("(GDHandle value) -> None")},
{"LMGetQDColors", (PyCFunction)Qd_LMGetQDColors, 1,
"() -> (Handle _rv)"},
PyDoc_STR("() -> (Handle _rv)")},
{"LMSetQDColors", (PyCFunction)Qd_LMSetQDColors, 1,
"(Handle value) -> None"},
PyDoc_STR("(Handle value) -> None")},
{"LMGetWidthListHand", (PyCFunction)Qd_LMGetWidthListHand, 1,
"() -> (Handle _rv)"},
PyDoc_STR("() -> (Handle _rv)")},
{"LMSetWidthListHand", (PyCFunction)Qd_LMSetWidthListHand, 1,
"(Handle value) -> None"},
PyDoc_STR("(Handle value) -> None")},
{"LMGetHiliteMode", (PyCFunction)Qd_LMGetHiliteMode, 1,
"() -> (UInt8 _rv)"},
PyDoc_STR("() -> (UInt8 _rv)")},
{"LMSetHiliteMode", (PyCFunction)Qd_LMSetHiliteMode, 1,
"(UInt8 value) -> None"},
PyDoc_STR("(UInt8 value) -> None")},
{"LMGetWidthTabHandle", (PyCFunction)Qd_LMGetWidthTabHandle, 1,
"() -> (Handle _rv)"},
PyDoc_STR("() -> (Handle _rv)")},
{"LMSetWidthTabHandle", (PyCFunction)Qd_LMSetWidthTabHandle, 1,
"(Handle value) -> None"},
PyDoc_STR("(Handle value) -> None")},
{"LMGetLastSPExtra", (PyCFunction)Qd_LMGetLastSPExtra, 1,
"() -> (SInt32 _rv)"},
PyDoc_STR("() -> (SInt32 _rv)")},
{"LMSetLastSPExtra", (PyCFunction)Qd_LMSetLastSPExtra, 1,
"(SInt32 value) -> None"},
PyDoc_STR("(SInt32 value) -> None")},
{"LMGetLastFOND", (PyCFunction)Qd_LMGetLastFOND, 1,
"() -> (Handle _rv)"},
PyDoc_STR("() -> (Handle _rv)")},
{"LMSetLastFOND", (PyCFunction)Qd_LMSetLastFOND, 1,
"(Handle value) -> None"},
PyDoc_STR("(Handle value) -> None")},
{"LMGetFractEnable", (PyCFunction)Qd_LMGetFractEnable, 1,
"() -> (UInt8 _rv)"},
PyDoc_STR("() -> (UInt8 _rv)")},
{"LMSetFractEnable", (PyCFunction)Qd_LMSetFractEnable, 1,
"(UInt8 value) -> None"},
PyDoc_STR("(UInt8 value) -> None")},
{"LMGetTheGDevice", (PyCFunction)Qd_LMGetTheGDevice, 1,
"() -> (GDHandle _rv)"},
PyDoc_STR("() -> (GDHandle _rv)")},
{"LMSetTheGDevice", (PyCFunction)Qd_LMSetTheGDevice, 1,
"(GDHandle value) -> None"},
PyDoc_STR("(GDHandle value) -> None")},
{"LMGetHiliteRGB", (PyCFunction)Qd_LMGetHiliteRGB, 1,
"() -> (RGBColor hiliteRGBValue)"},
PyDoc_STR("() -> (RGBColor hiliteRGBValue)")},
{"LMSetHiliteRGB", (PyCFunction)Qd_LMSetHiliteRGB, 1,
"(RGBColor hiliteRGBValue) -> None"},
PyDoc_STR("(RGBColor hiliteRGBValue) -> None")},
{"LMGetCursorNew", (PyCFunction)Qd_LMGetCursorNew, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
{"LMSetCursorNew", (PyCFunction)Qd_LMSetCursorNew, 1,
"(Boolean value) -> None"},
PyDoc_STR("(Boolean value) -> None")},
{"TextFont", (PyCFunction)Qd_TextFont, 1,
"(short font) -> None"},
PyDoc_STR("(short font) -> None")},
{"TextFace", (PyCFunction)Qd_TextFace, 1,
"(StyleParameter face) -> None"},
PyDoc_STR("(StyleParameter face) -> None")},
{"TextMode", (PyCFunction)Qd_TextMode, 1,
"(short mode) -> None"},
PyDoc_STR("(short mode) -> None")},
{"TextSize", (PyCFunction)Qd_TextSize, 1,
"(short size) -> None"},
PyDoc_STR("(short size) -> None")},
{"SpaceExtra", (PyCFunction)Qd_SpaceExtra, 1,
"(Fixed extra) -> None"},
PyDoc_STR("(Fixed extra) -> None")},
{"DrawChar", (PyCFunction)Qd_DrawChar, 1,
"(CharParameter ch) -> None"},
PyDoc_STR("(CharParameter ch) -> None")},
{"DrawString", (PyCFunction)Qd_DrawString, 1,
"(Str255 s) -> None"},
PyDoc_STR("(Str255 s) -> None")},
{"MacDrawText", (PyCFunction)Qd_MacDrawText, 1,
"(Buffer textBuf, short firstByte, short byteCount) -> None"},
PyDoc_STR("(Buffer textBuf, short firstByte, short byteCount) -> None")},
{"CharWidth", (PyCFunction)Qd_CharWidth, 1,
"(CharParameter ch) -> (short _rv)"},
PyDoc_STR("(CharParameter ch) -> (short _rv)")},
{"StringWidth", (PyCFunction)Qd_StringWidth, 1,
"(Str255 s) -> (short _rv)"},
PyDoc_STR("(Str255 s) -> (short _rv)")},
{"TextWidth", (PyCFunction)Qd_TextWidth, 1,
"(Buffer textBuf, short firstByte, short byteCount) -> (short _rv)"},
PyDoc_STR("(Buffer textBuf, short firstByte, short byteCount) -> (short _rv)")},
{"GetFontInfo", (PyCFunction)Qd_GetFontInfo, 1,
"() -> (FontInfo info)"},
PyDoc_STR("() -> (FontInfo info)")},
{"CharExtra", (PyCFunction)Qd_CharExtra, 1,
"(Fixed extra) -> None"},
PyDoc_STR("(Fixed extra) -> None")},
{"TruncString", (PyCFunction)Qd_TruncString, 1,
"(short width, Str255 theString, TruncCode truncWhere) -> (short _rv)"},
PyDoc_STR("(short width, Str255 theString, TruncCode truncWhere) -> (short _rv)")},
{"SetPort", (PyCFunction)Qd_SetPort, 1,
"(GrafPtr thePort) -> None"},
PyDoc_STR("(GrafPtr thePort) -> None")},
{"GetCursor", (PyCFunction)Qd_GetCursor, 1,
"(short cursorID) -> (CursHandle _rv)"},
PyDoc_STR("(short cursorID) -> (CursHandle _rv)")},
{"SetCursor", (PyCFunction)Qd_SetCursor, 1,
"(Cursor crsr) -> None"},
PyDoc_STR("(Cursor crsr) -> None")},
{"ShowCursor", (PyCFunction)Qd_ShowCursor, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"LineTo", (PyCFunction)Qd_LineTo, 1,
"(short h, short v) -> None"},
PyDoc_STR("(short h, short v) -> None")},
{"SetRect", (PyCFunction)Qd_SetRect, 1,
"(short left, short top, short right, short bottom) -> (Rect r)"},
PyDoc_STR("(short left, short top, short right, short bottom) -> (Rect r)")},
{"OffsetRect", (PyCFunction)Qd_OffsetRect, 1,
"(Rect r, short dh, short dv) -> (Rect r)"},
PyDoc_STR("(Rect r, short dh, short dv) -> (Rect r)")},
{"InsetRect", (PyCFunction)Qd_InsetRect, 1,
"(Rect r, short dh, short dv) -> (Rect r)"},
PyDoc_STR("(Rect r, short dh, short dv) -> (Rect r)")},
{"UnionRect", (PyCFunction)Qd_UnionRect, 1,
"(Rect src1, Rect src2) -> (Rect dstRect)"},
PyDoc_STR("(Rect src1, Rect src2) -> (Rect dstRect)")},
{"EqualRect", (PyCFunction)Qd_EqualRect, 1,
"(Rect rect1, Rect rect2) -> (Boolean _rv)"},
PyDoc_STR("(Rect rect1, Rect rect2) -> (Boolean _rv)")},
{"FrameRect", (PyCFunction)Qd_FrameRect, 1,
"(Rect r) -> None"},
PyDoc_STR("(Rect r) -> None")},
{"InvertRect", (PyCFunction)Qd_InvertRect, 1,
"(Rect r) -> None"},
PyDoc_STR("(Rect r) -> None")},
{"FillRect", (PyCFunction)Qd_FillRect, 1,
"(Rect r, Pattern pat) -> None"},
PyDoc_STR("(Rect r, Pattern pat) -> None")},
{"CopyRgn", (PyCFunction)Qd_CopyRgn, 1,
"(RgnHandle srcRgn, RgnHandle dstRgn) -> None"},
PyDoc_STR("(RgnHandle srcRgn, RgnHandle dstRgn) -> None")},
{"SetRectRgn", (PyCFunction)Qd_SetRectRgn, 1,
"(RgnHandle rgn, short left, short top, short right, short bottom) -> None"},
PyDoc_STR("(RgnHandle rgn, short left, short top, short right, short bottom) -> None")},
{"OffsetRgn", (PyCFunction)Qd_OffsetRgn, 1,
"(RgnHandle rgn, short dh, short dv) -> None"},
PyDoc_STR("(RgnHandle rgn, short dh, short dv) -> None")},
{"UnionRgn", (PyCFunction)Qd_UnionRgn, 1,
"(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")},
{"XorRgn", (PyCFunction)Qd_XorRgn, 1,
"(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None"},
PyDoc_STR("(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn) -> None")},
{"EqualRgn", (PyCFunction)Qd_EqualRgn, 1,
"(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)"},
PyDoc_STR("(RgnHandle rgnA, RgnHandle rgnB) -> (Boolean _rv)")},
{"FrameRgn", (PyCFunction)Qd_FrameRgn, 1,
"(RgnHandle rgn) -> None"},
PyDoc_STR("(RgnHandle rgn) -> None")},
{"PaintRgn", (PyCFunction)Qd_PaintRgn, 1,
"(RgnHandle rgn) -> None"},
PyDoc_STR("(RgnHandle rgn) -> None")},
{"InvertRgn", (PyCFunction)Qd_InvertRgn, 1,
"(RgnHandle rgn) -> None"},
PyDoc_STR("(RgnHandle rgn) -> None")},
{"FillRgn", (PyCFunction)Qd_FillRgn, 1,
"(RgnHandle rgn, Pattern pat) -> None"},
PyDoc_STR("(RgnHandle rgn, Pattern pat) -> None")},
{"GetPixel", (PyCFunction)Qd_GetPixel, 1,
"(short h, short v) -> (Boolean _rv)"},
PyDoc_STR("(short h, short v) -> (Boolean _rv)")},
{"PtInRect", (PyCFunction)Qd_PtInRect, 1,
"(Point pt, Rect r) -> (Boolean _rv)"},
PyDoc_STR("(Point pt, Rect r) -> (Boolean _rv)")},
{"DrawText", (PyCFunction)Qd_DrawText, 1,
"(Buffer textBuf, short firstByte, short byteCount) -> None"},
PyDoc_STR("(Buffer textBuf, short firstByte, short byteCount) -> None")},
{"BitMap", (PyCFunction)Qd_BitMap, 1,
"Take (string, int, Rect) argument and create BitMap"},
PyDoc_STR("Take (string, int, Rect) argument and create BitMap")},
{"RawBitMap", (PyCFunction)Qd_RawBitMap, 1,
"Take string BitMap and turn into BitMap object"},
PyDoc_STR("Take string BitMap and turn into BitMap object")},
{NULL, NULL, 0}
};

52
Mac/Modules/qdoffs/_Qdoffsmodule.c
View File

@ -123,11 +123,11 @@ static PyObject *GWorldObj_as_GrafPtr(GWorldObject *_self, PyObject *_args)
static PyMethodDef GWorldObj_methods[] = {
{"GetGWorldDevice", (PyCFunction)GWorldObj_GetGWorldDevice, 1,
"() -> (GDHandle _rv)"},
PyDoc_STR("() -> (GDHandle _rv)")},
{"GetGWorldPixMap", (PyCFunction)GWorldObj_GetGWorldPixMap, 1,
"() -> (PixMapHandle _rv)"},
PyDoc_STR("() -> (PixMapHandle _rv)")},
{"as_GrafPtr", (PyCFunction)GWorldObj_as_GrafPtr, 1,
"() -> (GrafPtr _rv)"},
PyDoc_STR("() -> (GrafPtr _rv)")},
{NULL, NULL, 0}
};
@ -604,51 +604,51 @@ static PyObject *Qdoffs_PutPixMapBytes(PyObject *_self, PyObject *_args)
static PyMethodDef Qdoffs_methods[] = {
{"NewGWorld", (PyCFunction)Qdoffs_NewGWorld, 1,
"(short PixelDepth, Rect boundsRect, CTabHandle cTable, GDHandle aGDevice, GWorldFlags flags) -> (GWorldPtr offscreenGWorld)"},
PyDoc_STR("(short PixelDepth, Rect boundsRect, CTabHandle cTable, GDHandle aGDevice, GWorldFlags flags) -> (GWorldPtr offscreenGWorld)")},
{"LockPixels", (PyCFunction)Qdoffs_LockPixels, 1,
"(PixMapHandle pm) -> (Boolean _rv)"},
PyDoc_STR("(PixMapHandle pm) -> (Boolean _rv)")},
{"UnlockPixels", (PyCFunction)Qdoffs_UnlockPixels, 1,
"(PixMapHandle pm) -> None"},
PyDoc_STR("(PixMapHandle pm) -> None")},
{"UpdateGWorld", (PyCFunction)Qdoffs_UpdateGWorld, 1,
"(short pixelDepth, Rect boundsRect, CTabHandle cTable, GDHandle aGDevice, GWorldFlags flags) -> (GWorldFlags _rv, GWorldPtr offscreenGWorld)"},
PyDoc_STR("(short pixelDepth, Rect boundsRect, CTabHandle cTable, GDHandle aGDevice, GWorldFlags flags) -> (GWorldFlags _rv, GWorldPtr offscreenGWorld)")},
{"GetGWorld", (PyCFunction)Qdoffs_GetGWorld, 1,
"() -> (CGrafPtr port, GDHandle gdh)"},
PyDoc_STR("() -> (CGrafPtr port, GDHandle gdh)")},
{"SetGWorld", (PyCFunction)Qdoffs_SetGWorld, 1,
"(CGrafPtr port, GDHandle gdh) -> None"},
PyDoc_STR("(CGrafPtr port, GDHandle gdh) -> None")},
{"CTabChanged", (PyCFunction)Qdoffs_CTabChanged, 1,
"(CTabHandle ctab) -> None"},
PyDoc_STR("(CTabHandle ctab) -> None")},
{"PixPatChanged", (PyCFunction)Qdoffs_PixPatChanged, 1,
"(PixPatHandle ppat) -> None"},
PyDoc_STR("(PixPatHandle ppat) -> None")},
{"PortChanged", (PyCFunction)Qdoffs_PortChanged, 1,
"(GrafPtr port) -> None"},
PyDoc_STR("(GrafPtr port) -> None")},
{"GDeviceChanged", (PyCFunction)Qdoffs_GDeviceChanged, 1,
"(GDHandle gdh) -> None"},
PyDoc_STR("(GDHandle gdh) -> None")},
{"AllowPurgePixels", (PyCFunction)Qdoffs_AllowPurgePixels, 1,
"(PixMapHandle pm) -> None"},
PyDoc_STR("(PixMapHandle pm) -> None")},
{"NoPurgePixels", (PyCFunction)Qdoffs_NoPurgePixels, 1,
"(PixMapHandle pm) -> None"},
PyDoc_STR("(PixMapHandle pm) -> None")},
{"GetPixelsState", (PyCFunction)Qdoffs_GetPixelsState, 1,
"(PixMapHandle pm) -> (GWorldFlags _rv)"},
PyDoc_STR("(PixMapHandle pm) -> (GWorldFlags _rv)")},
{"SetPixelsState", (PyCFunction)Qdoffs_SetPixelsState, 1,
"(PixMapHandle pm, GWorldFlags state) -> None"},
PyDoc_STR("(PixMapHandle pm, GWorldFlags state) -> None")},
{"GetPixRowBytes", (PyCFunction)Qdoffs_GetPixRowBytes, 1,
"(PixMapHandle pm) -> (long _rv)"},
PyDoc_STR("(PixMapHandle pm) -> (long _rv)")},
{"NewScreenBuffer", (PyCFunction)Qdoffs_NewScreenBuffer, 1,
"(Rect globalRect, Boolean purgeable) -> (GDHandle gdh, PixMapHandle offscreenPixMap)"},
PyDoc_STR("(Rect globalRect, Boolean purgeable) -> (GDHandle gdh, PixMapHandle offscreenPixMap)")},
{"DisposeScreenBuffer", (PyCFunction)Qdoffs_DisposeScreenBuffer, 1,
"(PixMapHandle offscreenPixMap) -> None"},
PyDoc_STR("(PixMapHandle offscreenPixMap) -> None")},
{"QDDone", (PyCFunction)Qdoffs_QDDone, 1,
"(GrafPtr port) -> (Boolean _rv)"},
PyDoc_STR("(GrafPtr port) -> (Boolean _rv)")},
{"OffscreenVersion", (PyCFunction)Qdoffs_OffscreenVersion, 1,
"() -> (long _rv)"},
PyDoc_STR("() -> (long _rv)")},
{"NewTempScreenBuffer", (PyCFunction)Qdoffs_NewTempScreenBuffer, 1,
"(Rect globalRect, Boolean purgeable) -> (GDHandle gdh, PixMapHandle offscreenPixMap)"},
PyDoc_STR("(Rect globalRect, Boolean purgeable) -> (GDHandle gdh, PixMapHandle offscreenPixMap)")},
{"PixMap32Bit", (PyCFunction)Qdoffs_PixMap32Bit, 1,
"(PixMapHandle pmHandle) -> (Boolean _rv)"},
PyDoc_STR("(PixMapHandle pmHandle) -> (Boolean _rv)")},
{"GetPixMapBytes", (PyCFunction)Qdoffs_GetPixMapBytes, 1,
"(pixmap, int start, int size) -> string. Return bytes from the pixmap"},
PyDoc_STR("(pixmap, int start, int size) -> string. Return bytes from the pixmap")},
{"PutPixMapBytes", (PyCFunction)Qdoffs_PutPixMapBytes, 1,
"(pixmap, int start, string data). Store bytes into the pixmap"},
PyDoc_STR("(pixmap, int start, string data). Store bytes into the pixmap")},
{NULL, NULL, 0}
};

810
Mac/Modules/qt/_Qtmodule.c
View File

File diff suppressed because it is too large Load Diff

134
Mac/Modules/res/_Resmodule.c
View File

@ -501,50 +501,50 @@ static PyObject *ResObj_AutoDispose(ResourceObject *_self, PyObject *_args)
static PyMethodDef ResObj_methods[] = {
{"HomeResFile", (PyCFunction)ResObj_HomeResFile, 1,
"() -> (short _rv)"},
PyDoc_STR("() -> (short _rv)")},
{"MacLoadResource", (PyCFunction)ResObj_MacLoadResource, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"ReleaseResource", (PyCFunction)ResObj_ReleaseResource, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"DetachResource", (PyCFunction)ResObj_DetachResource, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"GetResAttrs", (PyCFunction)ResObj_GetResAttrs, 1,
"() -> (short _rv)"},
PyDoc_STR("() -> (short _rv)")},
{"GetResInfo", (PyCFunction)ResObj_GetResInfo, 1,
"() -> (short theID, ResType theType, Str255 name)"},
PyDoc_STR("() -> (short theID, ResType theType, Str255 name)")},
{"SetResInfo", (PyCFunction)ResObj_SetResInfo, 1,
"(short theID, Str255 name) -> None"},
PyDoc_STR("(short theID, Str255 name) -> None")},
{"AddResource", (PyCFunction)ResObj_AddResource, 1,
"(ResType theType, short theID, Str255 name) -> None"},
PyDoc_STR("(ResType theType, short theID, Str255 name) -> None")},
{"GetResourceSizeOnDisk", (PyCFunction)ResObj_GetResourceSizeOnDisk, 1,
"() -> (long _rv)"},
PyDoc_STR("() -> (long _rv)")},
{"GetMaxResourceSize", (PyCFunction)ResObj_GetMaxResourceSize, 1,
"() -> (long _rv)"},
PyDoc_STR("() -> (long _rv)")},
#if TARGET_API_MAC_OS8
{"RsrcMapEntry", (PyCFunction)ResObj_RsrcMapEntry, 1,
"() -> (long _rv)"},
PyDoc_STR("() -> (long _rv)")},
#endif
{"SetResAttrs", (PyCFunction)ResObj_SetResAttrs, 1,
"(short attrs) -> None"},
PyDoc_STR("(short attrs) -> None")},
{"ChangedResource", (PyCFunction)ResObj_ChangedResource, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"RemoveResource", (PyCFunction)ResObj_RemoveResource, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"WriteResource", (PyCFunction)ResObj_WriteResource, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"SetResourceSize", (PyCFunction)ResObj_SetResourceSize, 1,
"(long newSize) -> None"},
PyDoc_STR("(long newSize) -> None")},
{"GetNextFOND", (PyCFunction)ResObj_GetNextFOND, 1,
"() -> (Handle _rv)"},
PyDoc_STR("() -> (Handle _rv)")},
{"as_Control", (PyCFunction)ResObj_as_Control, 1,
"Return this resource/handle as a Control"},
PyDoc_STR("Return this resource/handle as a Control")},
{"as_Menu", (PyCFunction)ResObj_as_Menu, 1,
"Return this resource/handle as a Menu"},
PyDoc_STR("Return this resource/handle as a Menu")},
{"LoadResource", (PyCFunction)ResObj_LoadResource, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"AutoDispose", (PyCFunction)ResObj_AutoDispose, 1,
"(int)->int. Automatically DisposeHandle the object on Python object cleanup"},
PyDoc_STR("(int)->int. Automatically DisposeHandle the object on Python object cleanup")},
{NULL, NULL, 0}
};
@ -1720,134 +1720,134 @@ static PyMethodDef Res_methods[] = {
#if TARGET_API_MAC_OS8
{"InitResources", (PyCFunction)Res_InitResources, 1,
"() -> (short _rv)"},
PyDoc_STR("() -> (short _rv)")},
#endif
#if TARGET_API_MAC_OS8
{"RsrcZoneInit", (PyCFunction)Res_RsrcZoneInit, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
{"CloseResFile", (PyCFunction)Res_CloseResFile, 1,
"(short refNum) -> None"},
PyDoc_STR("(short refNum) -> None")},
{"ResError", (PyCFunction)Res_ResError, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CurResFile", (PyCFunction)Res_CurResFile, 1,
"() -> (short _rv)"},
PyDoc_STR("() -> (short _rv)")},
#if TARGET_API_MAC_OS8
{"CreateResFile", (PyCFunction)Res_CreateResFile, 1,
"(Str255 fileName) -> None"},
PyDoc_STR("(Str255 fileName) -> None")},
#endif
#if TARGET_API_MAC_OS8
{"OpenResFile", (PyCFunction)Res_OpenResFile, 1,
"(Str255 fileName) -> (short _rv)"},
PyDoc_STR("(Str255 fileName) -> (short _rv)")},
#endif
{"UseResFile", (PyCFunction)Res_UseResFile, 1,
"(short refNum) -> None"},
PyDoc_STR("(short refNum) -> None")},
{"CountTypes", (PyCFunction)Res_CountTypes, 1,
"() -> (short _rv)"},
PyDoc_STR("() -> (short _rv)")},
{"Count1Types", (PyCFunction)Res_Count1Types, 1,
"() -> (short _rv)"},
PyDoc_STR("() -> (short _rv)")},
{"GetIndType", (PyCFunction)Res_GetIndType, 1,
"(short index) -> (ResType theType)"},
PyDoc_STR("(short index) -> (ResType theType)")},
{"Get1IndType", (PyCFunction)Res_Get1IndType, 1,
"(short index) -> (ResType theType)"},
PyDoc_STR("(short index) -> (ResType theType)")},
{"SetResLoad", (PyCFunction)Res_SetResLoad, 1,
"(Boolean load) -> None"},
PyDoc_STR("(Boolean load) -> None")},
{"CountResources", (PyCFunction)Res_CountResources, 1,
"(ResType theType) -> (short _rv)"},
PyDoc_STR("(ResType theType) -> (short _rv)")},
{"Count1Resources", (PyCFunction)Res_Count1Resources, 1,
"(ResType theType) -> (short _rv)"},
PyDoc_STR("(ResType theType) -> (short _rv)")},
{"GetIndResource", (PyCFunction)Res_GetIndResource, 1,
"(ResType theType, short index) -> (Handle _rv)"},
PyDoc_STR("(ResType theType, short index) -> (Handle _rv)")},
{"Get1IndResource", (PyCFunction)Res_Get1IndResource, 1,
"(ResType theType, short index) -> (Handle _rv)"},
PyDoc_STR("(ResType theType, short index) -> (Handle _rv)")},
{"GetResource", (PyCFunction)Res_GetResource, 1,
"(ResType theType, short theID) -> (Handle _rv)"},
PyDoc_STR("(ResType theType, short theID) -> (Handle _rv)")},
{"Get1Resource", (PyCFunction)Res_Get1Resource, 1,
"(ResType theType, short theID) -> (Handle _rv)"},
PyDoc_STR("(ResType theType, short theID) -> (Handle _rv)")},
{"GetNamedResource", (PyCFunction)Res_GetNamedResource, 1,
"(ResType theType, Str255 name) -> (Handle _rv)"},
PyDoc_STR("(ResType theType, Str255 name) -> (Handle _rv)")},
{"Get1NamedResource", (PyCFunction)Res_Get1NamedResource, 1,
"(ResType theType, Str255 name) -> (Handle _rv)"},
PyDoc_STR("(ResType theType, Str255 name) -> (Handle _rv)")},
{"UniqueID", (PyCFunction)Res_UniqueID, 1,
"(ResType theType) -> (short _rv)"},
PyDoc_STR("(ResType theType) -> (short _rv)")},
{"Unique1ID", (PyCFunction)Res_Unique1ID, 1,
"(ResType theType) -> (short _rv)"},
PyDoc_STR("(ResType theType) -> (short _rv)")},
{"UpdateResFile", (PyCFunction)Res_UpdateResFile, 1,
"(short refNum) -> None"},
PyDoc_STR("(short refNum) -> None")},
{"SetResPurge", (PyCFunction)Res_SetResPurge, 1,
"(Boolean install) -> None"},
PyDoc_STR("(Boolean install) -> None")},
{"GetResFileAttrs", (PyCFunction)Res_GetResFileAttrs, 1,
"(short refNum) -> (short _rv)"},
PyDoc_STR("(short refNum) -> (short _rv)")},
{"SetResFileAttrs", (PyCFunction)Res_SetResFileAttrs, 1,
"(short refNum, short attrs) -> None"},
PyDoc_STR("(short refNum, short attrs) -> None")},
{"OpenRFPerm", (PyCFunction)Res_OpenRFPerm, 1,
"(Str255 fileName, short vRefNum, SignedByte permission) -> (short _rv)"},
PyDoc_STR("(Str255 fileName, short vRefNum, SignedByte permission) -> (short _rv)")},
#if TARGET_API_MAC_OS8
{"RGetResource", (PyCFunction)Res_RGetResource, 1,
"(ResType theType, short theID) -> (Handle _rv)"},
PyDoc_STR("(ResType theType, short theID) -> (Handle _rv)")},
#endif
{"HOpenResFile", (PyCFunction)Res_HOpenResFile, 1,
"(short vRefNum, long dirID, Str255 fileName, SignedByte permission) -> (short _rv)"},
PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SignedByte permission) -> (short _rv)")},
{"HCreateResFile", (PyCFunction)Res_HCreateResFile, 1,
"(short vRefNum, long dirID, Str255 fileName) -> None"},
PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")},
{"FSpOpenResFile", (PyCFunction)Res_FSpOpenResFile, 1,
"(FSSpec spec, SignedByte permission) -> (short _rv)"},
PyDoc_STR("(FSSpec spec, SignedByte permission) -> (short _rv)")},
{"FSpCreateResFile", (PyCFunction)Res_FSpCreateResFile, 1,
"(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None"},
PyDoc_STR("(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None")},
#if TARGET_API_MAC_CARBON
{"InsertResourceFile", (PyCFunction)Res_InsertResourceFile, 1,
"(SInt16 refNum, RsrcChainLocation where) -> None"},
PyDoc_STR("(SInt16 refNum, RsrcChainLocation where) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"DetachResourceFile", (PyCFunction)Res_DetachResourceFile, 1,
"(SInt16 refNum) -> None"},
PyDoc_STR("(SInt16 refNum) -> None")},
#endif
#if TARGET_API_MAC_CARBON
{"FSpResourceFileAlreadyOpen", (PyCFunction)Res_FSpResourceFileAlreadyOpen, 1,
"(FSSpec resourceFile) -> (Boolean _rv, Boolean inChain, SInt16 refNum)"},
PyDoc_STR("(FSSpec resourceFile) -> (Boolean _rv, Boolean inChain, SInt16 refNum)")},
#endif
#if TARGET_API_MAC_CARBON
{"FSpOpenOrphanResFile", (PyCFunction)Res_FSpOpenOrphanResFile, 1,
"(FSSpec spec, SignedByte permission) -> (SInt16 refNum)"},
PyDoc_STR("(FSSpec spec, SignedByte permission) -> (SInt16 refNum)")},
#endif
#if TARGET_API_MAC_CARBON
{"GetTopResourceFile", (PyCFunction)Res_GetTopResourceFile, 1,
"() -> (SInt16 refNum)"},
PyDoc_STR("() -> (SInt16 refNum)")},
#endif
#if TARGET_API_MAC_CARBON
{"GetNextResourceFile", (PyCFunction)Res_GetNextResourceFile, 1,
"(SInt16 curRefNum) -> (SInt16 nextRefNum)"},
PyDoc_STR("(SInt16 curRefNum) -> (SInt16 nextRefNum)")},
#endif
{"FSOpenResFile", (PyCFunction)Res_FSOpenResFile, 1,
"(FSRef ref, SignedByte permission) -> (short _rv)"},
PyDoc_STR("(FSRef ref, SignedByte permission) -> (short _rv)")},
{"FSCreateResFile", (PyCFunction)Res_FSCreateResFile, 1,
"(FSRef parentRef, Buffer nameLength) -> (FSRef newRef, FSSpec newSpec)"},
PyDoc_STR("(FSRef parentRef, Buffer nameLength) -> (FSRef newRef, FSSpec newSpec)")},
{"FSResourceFileAlreadyOpen", (PyCFunction)Res_FSResourceFileAlreadyOpen, 1,
"(FSRef resourceFileRef) -> (Boolean _rv, Boolean inChain, SInt16 refNum)"},
PyDoc_STR("(FSRef resourceFileRef) -> (Boolean _rv, Boolean inChain, SInt16 refNum)")},
#if TARGET_API_MAC_CARBON
{"FSCreateResourceFile", (PyCFunction)Res_FSCreateResourceFile, 1,
"(FSRef parentRef, Buffer nameLength, Buffer forkNameLength) -> (FSRef newRef, FSSpec newSpec)"},
PyDoc_STR("(FSRef parentRef, Buffer nameLength, Buffer forkNameLength) -> (FSRef newRef, FSSpec newSpec)")},
#endif
#if TARGET_API_MAC_CARBON
{"FSOpenResourceFile", (PyCFunction)Res_FSOpenResourceFile, 1,
"(FSRef ref, Buffer forkNameLength, SignedByte permissions) -> (SInt16 refNum)"},
PyDoc_STR("(FSRef ref, Buffer forkNameLength, SignedByte permissions) -> (SInt16 refNum)")},
#endif
{"Resource", (PyCFunction)Res_Resource, 1,
"Convert a string to a resource object.\n\nThe created resource object is actually just a handle,\napply AddResource() to write it to a resource file.\nSee also the Handle() docstring.\n"},
PyDoc_STR("Convert a string to a resource object.\n\nThe created resource object is actually just a handle,\napply AddResource() to write it to a resource file.\nSee also the Handle() docstring.\n")},
{"Handle", (PyCFunction)Res_Handle, 1,
"Convert a string to a Handle object.\n\nResource() and Handle() are very similar, but objects created with Handle() are\nby default automatically DisposeHandle()d upon object cleanup. Use AutoDispose()\nto change this.\n"},
PyDoc_STR("Convert a string to a Handle object.\n\nResource() and Handle() are very similar, but objects created with Handle() are\nby default automatically DisposeHandle()d upon object cleanup. Use AutoDispose()\nto change this.\n")},
{NULL, NULL, 0}
};

98
Mac/Modules/snd/_Sndmodule.c
View File

@ -271,32 +271,32 @@ static PyObject *SndCh_SndSetInfo(SndChannelObject *_self, PyObject *_args)
static PyMethodDef SndCh_methods[] = {
{"SndDoCommand", (PyCFunction)SndCh_SndDoCommand, 1,
"(SndCommand cmd, Boolean noWait) -> None"},
PyDoc_STR("(SndCommand cmd, Boolean noWait) -> None")},
{"SndDoImmediate", (PyCFunction)SndCh_SndDoImmediate, 1,
"(SndCommand cmd) -> None"},
PyDoc_STR("(SndCommand cmd) -> None")},
{"SndPlay", (PyCFunction)SndCh_SndPlay, 1,
"(SndListHandle sndHandle, Boolean async) -> None"},
PyDoc_STR("(SndListHandle sndHandle, Boolean async) -> None")},
#if !TARGET_API_MAC_CARBON
{"SndStartFilePlay", (PyCFunction)SndCh_SndStartFilePlay, 1,
"(short fRefNum, short resNum, long bufferSize, Boolean async) -> None"},
PyDoc_STR("(short fRefNum, short resNum, long bufferSize, Boolean async) -> None")},
#endif
#if !TARGET_API_MAC_CARBON
{"SndPauseFilePlay", (PyCFunction)SndCh_SndPauseFilePlay, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
#if !TARGET_API_MAC_CARBON
{"SndStopFilePlay", (PyCFunction)SndCh_SndStopFilePlay, 1,
"(Boolean quietNow) -> None"},
PyDoc_STR("(Boolean quietNow) -> None")},
#endif
{"SndChannelStatus", (PyCFunction)SndCh_SndChannelStatus, 1,
"(short theLength) -> (SCStatus theStatus)"},
PyDoc_STR("(short theLength) -> (SCStatus theStatus)")},
{"SndGetInfo", (PyCFunction)SndCh_SndGetInfo, 1,
"(OSType selector, void * infoPtr) -> None"},
PyDoc_STR("(OSType selector, void * infoPtr) -> None")},
{"SndSetInfo", (PyCFunction)SndCh_SndSetInfo, 1,
"(OSType selector, void * infoPtr) -> None"},
PyDoc_STR("(OSType selector, void * infoPtr) -> None")},
{NULL, NULL, 0}
};
@ -1292,109 +1292,109 @@ static PyObject *Snd_SPBBytesToMilliseconds(PyObject *_self, PyObject *_args)
static PyMethodDef Snd_methods[] = {
{"SPB", (PyCFunction)Snd_SPB, 1,
NULL},
PyDoc_STR(NULL)},
{"SysBeep", (PyCFunction)Snd_SysBeep, 1,
"(short duration) -> None"},
PyDoc_STR("(short duration) -> None")},
{"SndNewChannel", (PyCFunction)Snd_SndNewChannel, 1,
"(short synth, long init, PyObject* userRoutine) -> (SndChannelPtr chan)"},
PyDoc_STR("(short synth, long init, PyObject* userRoutine) -> (SndChannelPtr chan)")},
#if !TARGET_API_MAC_CARBON
{"SndControl", (PyCFunction)Snd_SndControl, 1,
"(short id) -> (SndCommand cmd)"},
PyDoc_STR("(short id) -> (SndCommand cmd)")},
#endif
{"SndSoundManagerVersion", (PyCFunction)Snd_SndSoundManagerVersion, 1,
"() -> (NumVersion _rv)"},
PyDoc_STR("() -> (NumVersion _rv)")},
{"SndManagerStatus", (PyCFunction)Snd_SndManagerStatus, 1,
"(short theLength) -> (SMStatus theStatus)"},
PyDoc_STR("(short theLength) -> (SMStatus theStatus)")},
{"SndGetSysBeepState", (PyCFunction)Snd_SndGetSysBeepState, 1,
"() -> (short sysBeepState)"},
PyDoc_STR("() -> (short sysBeepState)")},
{"SndSetSysBeepState", (PyCFunction)Snd_SndSetSysBeepState, 1,
"(short sysBeepState) -> None"},
PyDoc_STR("(short sysBeepState) -> None")},
#if !TARGET_API_MAC_CARBON
{"MACEVersion", (PyCFunction)Snd_MACEVersion, 1,
"() -> (NumVersion _rv)"},
PyDoc_STR("() -> (NumVersion _rv)")},
#endif
#if !TARGET_API_MAC_CARBON
{"Comp3to1", (PyCFunction)Snd_Comp3to1, 1,
"(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"},
PyDoc_STR("(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)")},
#endif
#if !TARGET_API_MAC_CARBON
{"Exp1to3", (PyCFunction)Snd_Exp1to3, 1,
"(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"},
PyDoc_STR("(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)")},
#endif
#if !TARGET_API_MAC_CARBON
{"Comp6to1", (PyCFunction)Snd_Comp6to1, 1,
"(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"},
PyDoc_STR("(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)")},
#endif
#if !TARGET_API_MAC_CARBON
{"Exp1to6", (PyCFunction)Snd_Exp1to6, 1,
"(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)"},
PyDoc_STR("(Buffer buffer, StateBlock state, unsigned long numChannels, unsigned long whichChannel) -> (Buffer buffer, StateBlock state)")},
#endif
{"GetSysBeepVolume", (PyCFunction)Snd_GetSysBeepVolume, 1,
"() -> (long level)"},
PyDoc_STR("() -> (long level)")},
{"SetSysBeepVolume", (PyCFunction)Snd_SetSysBeepVolume, 1,
"(long level) -> None"},
PyDoc_STR("(long level) -> None")},
{"GetDefaultOutputVolume", (PyCFunction)Snd_GetDefaultOutputVolume, 1,
"() -> (long level)"},
PyDoc_STR("() -> (long level)")},
{"SetDefaultOutputVolume", (PyCFunction)Snd_SetDefaultOutputVolume, 1,
"(long level) -> None"},
PyDoc_STR("(long level) -> None")},
{"GetSoundHeaderOffset", (PyCFunction)Snd_GetSoundHeaderOffset, 1,
"(SndListHandle sndHandle) -> (long offset)"},
PyDoc_STR("(SndListHandle sndHandle) -> (long offset)")},
{"GetCompressionInfo", (PyCFunction)Snd_GetCompressionInfo, 1,
"(short compressionID, OSType format, short numChannels, short sampleSize) -> (CompressionInfo cp)"},
PyDoc_STR("(short compressionID, OSType format, short numChannels, short sampleSize) -> (CompressionInfo cp)")},
{"SetSoundPreference", (PyCFunction)Snd_SetSoundPreference, 1,
"(OSType theType, Handle settings) -> (Str255 name)"},
PyDoc_STR("(OSType theType, Handle settings) -> (Str255 name)")},
{"GetSoundPreference", (PyCFunction)Snd_GetSoundPreference, 1,
"(OSType theType, Handle settings) -> (Str255 name)"},
PyDoc_STR("(OSType theType, Handle settings) -> (Str255 name)")},
{"GetCompressionName", (PyCFunction)Snd_GetCompressionName, 1,
"(OSType compressionType) -> (Str255 compressionName)"},
PyDoc_STR("(OSType compressionType) -> (Str255 compressionName)")},
{"SPBVersion", (PyCFunction)Snd_SPBVersion, 1,
"() -> (NumVersion _rv)"},
PyDoc_STR("() -> (NumVersion _rv)")},
{"SndRecord", (PyCFunction)Snd_SndRecord, 1,
"(Point corner, OSType quality) -> (SndListHandle sndHandle)"},
PyDoc_STR("(Point corner, OSType quality) -> (SndListHandle sndHandle)")},
#if !TARGET_API_MAC_CARBON
{"SndRecordToFile", (PyCFunction)Snd_SndRecordToFile, 1,
"(Point corner, OSType quality, short fRefNum) -> None"},
PyDoc_STR("(Point corner, OSType quality, short fRefNum) -> None")},
#endif
{"SPBSignInDevice", (PyCFunction)Snd_SPBSignInDevice, 1,
"(short deviceRefNum, Str255 deviceName) -> None"},
PyDoc_STR("(short deviceRefNum, Str255 deviceName) -> None")},
{"SPBSignOutDevice", (PyCFunction)Snd_SPBSignOutDevice, 1,
"(short deviceRefNum) -> None"},
PyDoc_STR("(short deviceRefNum) -> None")},
{"SPBGetIndexedDevice", (PyCFunction)Snd_SPBGetIndexedDevice, 1,
"(short count) -> (Str255 deviceName, Handle deviceIconHandle)"},
PyDoc_STR("(short count) -> (Str255 deviceName, Handle deviceIconHandle)")},
{"SPBOpenDevice", (PyCFunction)Snd_SPBOpenDevice, 1,
"(Str255 deviceName, short permission) -> (long inRefNum)"},
PyDoc_STR("(Str255 deviceName, short permission) -> (long inRefNum)")},
{"SPBCloseDevice", (PyCFunction)Snd_SPBCloseDevice, 1,
"(long inRefNum) -> None"},
PyDoc_STR("(long inRefNum) -> None")},
{"SPBRecord", (PyCFunction)Snd_SPBRecord, 1,
"(SPBPtr inParamPtr, Boolean asynchFlag) -> None"},
PyDoc_STR("(SPBPtr inParamPtr, Boolean asynchFlag) -> None")},
#if !TARGET_API_MAC_CARBON
{"SPBRecordToFile", (PyCFunction)Snd_SPBRecordToFile, 1,
"(short fRefNum, SPBPtr inParamPtr, Boolean asynchFlag) -> None"},
PyDoc_STR("(short fRefNum, SPBPtr inParamPtr, Boolean asynchFlag) -> None")},
#endif
{"SPBPauseRecording", (PyCFunction)Snd_SPBPauseRecording, 1,
"(long inRefNum) -> None"},
PyDoc_STR("(long inRefNum) -> None")},
{"SPBResumeRecording", (PyCFunction)Snd_SPBResumeRecording, 1,
"(long inRefNum) -> None"},
PyDoc_STR("(long inRefNum) -> None")},
{"SPBStopRecording", (PyCFunction)Snd_SPBStopRecording, 1,
"(long inRefNum) -> None"},
PyDoc_STR("(long inRefNum) -> None")},
{"SPBGetRecordingStatus", (PyCFunction)Snd_SPBGetRecordingStatus, 1,
"(long inRefNum) -> (short recordingStatus, short meterLevel, unsigned long totalSamplesToRecord, unsigned long numberOfSamplesRecorded, unsigned long totalMsecsToRecord, unsigned long numberOfMsecsRecorded)"},
PyDoc_STR("(long inRefNum) -> (short recordingStatus, short meterLevel, unsigned long totalSamplesToRecord, unsigned long numberOfSamplesRecorded, unsigned long totalMsecsToRecord, unsigned long numberOfMsecsRecorded)")},
{"SPBGetDeviceInfo", (PyCFunction)Snd_SPBGetDeviceInfo, 1,
"(long inRefNum, OSType infoType, void * infoData) -> None"},
PyDoc_STR("(long inRefNum, OSType infoType, void * infoData) -> None")},
{"SPBSetDeviceInfo", (PyCFunction)Snd_SPBSetDeviceInfo, 1,
"(long inRefNum, OSType infoType, void * infoData) -> None"},
PyDoc_STR("(long inRefNum, OSType infoType, void * infoData) -> None")},
{"SPBMillisecondsToBytes", (PyCFunction)Snd_SPBMillisecondsToBytes, 1,
"(long inRefNum) -> (long milliseconds)"},
PyDoc_STR("(long inRefNum) -> (long milliseconds)")},
{"SPBBytesToMilliseconds", (PyCFunction)Snd_SPBBytesToMilliseconds, 1,
"(long inRefNum) -> (long byteCount)"},
PyDoc_STR("(long inRefNum) -> (long byteCount)")},
{NULL, NULL, 0}
};

100
Mac/Modules/te/_TEmodule.c
View File

@ -774,79 +774,79 @@ static PyObject *TEObj_as_Resource(TEObject *_self, PyObject *_args)
static PyMethodDef TEObj_methods[] = {
{"TESetText", (PyCFunction)TEObj_TESetText, 1,
"(Buffer text) -> None"},
PyDoc_STR("(Buffer text) -> None")},
{"TEGetText", (PyCFunction)TEObj_TEGetText, 1,
"() -> (CharsHandle _rv)"},
PyDoc_STR("() -> (CharsHandle _rv)")},
{"TEIdle", (PyCFunction)TEObj_TEIdle, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"TESetSelect", (PyCFunction)TEObj_TESetSelect, 1,
"(long selStart, long selEnd) -> None"},
PyDoc_STR("(long selStart, long selEnd) -> None")},
{"TEActivate", (PyCFunction)TEObj_TEActivate, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"TEDeactivate", (PyCFunction)TEObj_TEDeactivate, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"TEKey", (PyCFunction)TEObj_TEKey, 1,
"(CharParameter key) -> None"},
PyDoc_STR("(CharParameter key) -> None")},
{"TECut", (PyCFunction)TEObj_TECut, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"TECopy", (PyCFunction)TEObj_TECopy, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"TEPaste", (PyCFunction)TEObj_TEPaste, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"TEDelete", (PyCFunction)TEObj_TEDelete, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"TEInsert", (PyCFunction)TEObj_TEInsert, 1,
"(Buffer text) -> None"},
PyDoc_STR("(Buffer text) -> None")},
{"TESetAlignment", (PyCFunction)TEObj_TESetAlignment, 1,
"(short just) -> None"},
PyDoc_STR("(short just) -> None")},
{"TEUpdate", (PyCFunction)TEObj_TEUpdate, 1,
"(Rect rUpdate) -> None"},
PyDoc_STR("(Rect rUpdate) -> None")},
{"TEScroll", (PyCFunction)TEObj_TEScroll, 1,
"(short dh, short dv) -> None"},
PyDoc_STR("(short dh, short dv) -> None")},
{"TESelView", (PyCFunction)TEObj_TESelView, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"TEPinScroll", (PyCFunction)TEObj_TEPinScroll, 1,
"(short dh, short dv) -> None"},
PyDoc_STR("(short dh, short dv) -> None")},
{"TEAutoView", (PyCFunction)TEObj_TEAutoView, 1,
"(Boolean fAuto) -> None"},
PyDoc_STR("(Boolean fAuto) -> None")},
{"TECalText", (PyCFunction)TEObj_TECalText, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"TEGetOffset", (PyCFunction)TEObj_TEGetOffset, 1,
"(Point pt) -> (short _rv)"},
PyDoc_STR("(Point pt) -> (short _rv)")},
{"TEGetPoint", (PyCFunction)TEObj_TEGetPoint, 1,
"(short offset) -> (Point _rv)"},
PyDoc_STR("(short offset) -> (Point _rv)")},
{"TEClick", (PyCFunction)TEObj_TEClick, 1,
"(Point pt, Boolean fExtend) -> None"},
PyDoc_STR("(Point pt, Boolean fExtend) -> None")},
{"TESetStyleHandle", (PyCFunction)TEObj_TESetStyleHandle, 1,
"(TEStyleHandle theHandle) -> None"},
PyDoc_STR("(TEStyleHandle theHandle) -> None")},
{"TEGetStyleHandle", (PyCFunction)TEObj_TEGetStyleHandle, 1,
"() -> (TEStyleHandle _rv)"},
PyDoc_STR("() -> (TEStyleHandle _rv)")},
{"TEGetStyle", (PyCFunction)TEObj_TEGetStyle, 1,
"(short offset) -> (TextStyle theStyle, short lineHeight, short fontAscent)"},
PyDoc_STR("(short offset) -> (TextStyle theStyle, short lineHeight, short fontAscent)")},
{"TEStylePaste", (PyCFunction)TEObj_TEStylePaste, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"TESetStyle", (PyCFunction)TEObj_TESetStyle, 1,
"(short mode, TextStyle newStyle, Boolean fRedraw) -> None"},
PyDoc_STR("(short mode, TextStyle newStyle, Boolean fRedraw) -> None")},
{"TEReplaceStyle", (PyCFunction)TEObj_TEReplaceStyle, 1,
"(short mode, TextStyle oldStyle, TextStyle newStyle, Boolean fRedraw) -> None"},
PyDoc_STR("(short mode, TextStyle oldStyle, TextStyle newStyle, Boolean fRedraw) -> None")},
{"TEGetStyleScrapHandle", (PyCFunction)TEObj_TEGetStyleScrapHandle, 1,
"() -> (StScrpHandle _rv)"},
PyDoc_STR("() -> (StScrpHandle _rv)")},
{"TEStyleInsert", (PyCFunction)TEObj_TEStyleInsert, 1,
"(Buffer text, StScrpHandle hST) -> None"},
PyDoc_STR("(Buffer text, StScrpHandle hST) -> None")},
{"TEGetHeight", (PyCFunction)TEObj_TEGetHeight, 1,
"(long endLine, long startLine) -> (long _rv)"},
PyDoc_STR("(long endLine, long startLine) -> (long _rv)")},
{"TEContinuousStyle", (PyCFunction)TEObj_TEContinuousStyle, 1,
"(short mode, TextStyle aStyle) -> (Boolean _rv, short mode, TextStyle aStyle)"},
PyDoc_STR("(short mode, TextStyle aStyle) -> (Boolean _rv, short mode, TextStyle aStyle)")},
{"TEUseStyleScrap", (PyCFunction)TEObj_TEUseStyleScrap, 1,
"(long rangeStart, long rangeEnd, StScrpHandle newStyles, Boolean fRedraw) -> None"},
PyDoc_STR("(long rangeStart, long rangeEnd, StScrpHandle newStyles, Boolean fRedraw) -> None")},
{"TENumStyles", (PyCFunction)TEObj_TENumStyles, 1,
"(long rangeStart, long rangeEnd) -> (long _rv)"},
PyDoc_STR("(long rangeStart, long rangeEnd) -> (long _rv)")},
{"TEFeatureFlag", (PyCFunction)TEObj_TEFeatureFlag, 1,
"(short feature, short action) -> (short _rv)"},
PyDoc_STR("(short feature, short action) -> (short _rv)")},
{"TEGetHiliteRgn", (PyCFunction)TEObj_TEGetHiliteRgn, 1,
"(RgnHandle region) -> None"},
PyDoc_STR("(RgnHandle region) -> None")},
{"as_Resource", (PyCFunction)TEObj_as_Resource, 1,
"() -> (Handle _rv)"},
PyDoc_STR("() -> (Handle _rv)")},
{NULL, NULL, 0}
};
@ -1155,37 +1155,37 @@ static PyObject *TE_as_TE(PyObject *_self, PyObject *_args)
static PyMethodDef TE_methods[] = {
{"TEScrapHandle", (PyCFunction)TE_TEScrapHandle, 1,
"() -> (Handle _rv)"},
PyDoc_STR("() -> (Handle _rv)")},
{"TEGetScrapLength", (PyCFunction)TE_TEGetScrapLength, 1,
"() -> (long _rv)"},
PyDoc_STR("() -> (long _rv)")},
{"TENew", (PyCFunction)TE_TENew, 1,
"(Rect destRect, Rect viewRect) -> (TEHandle _rv)"},
PyDoc_STR("(Rect destRect, Rect viewRect) -> (TEHandle _rv)")},
{"TETextBox", (PyCFunction)TE_TETextBox, 1,
"(Buffer text, Rect box, short just) -> None"},
PyDoc_STR("(Buffer text, Rect box, short just) -> None")},
{"TEStyleNew", (PyCFunction)TE_TEStyleNew, 1,
"(Rect destRect, Rect viewRect) -> (TEHandle _rv)"},
PyDoc_STR("(Rect destRect, Rect viewRect) -> (TEHandle _rv)")},
{"TESetScrapLength", (PyCFunction)TE_TESetScrapLength, 1,
"(long length) -> None"},
PyDoc_STR("(long length) -> None")},
{"TEFromScrap", (PyCFunction)TE_TEFromScrap, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"TEToScrap", (PyCFunction)TE_TEToScrap, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#if TARGET_API_MAC_CARBON
{"TEGetScrapHandle", (PyCFunction)TE_TEGetScrapHandle, 1,
"() -> (Handle _rv)"},
PyDoc_STR("() -> (Handle _rv)")},
#endif
#if TARGET_API_MAC_CARBON
{"TESetScrapHandle", (PyCFunction)TE_TESetScrapHandle, 1,
"(Handle value) -> None"},
PyDoc_STR("(Handle value) -> None")},
#endif
{"LMGetWordRedraw", (PyCFunction)TE_LMGetWordRedraw, 1,
"() -> (UInt8 _rv)"},
PyDoc_STR("() -> (UInt8 _rv)")},
{"LMSetWordRedraw", (PyCFunction)TE_LMSetWordRedraw, 1,
"(UInt8 value) -> None"},
PyDoc_STR("(UInt8 value) -> None")},
{"as_TE", (PyCFunction)TE_as_TE, 1,
"(Handle h) -> (TEHandle _rv)"},
PyDoc_STR("(Handle h) -> (TEHandle _rv)")},
{NULL, NULL, 0}
};

324
Mac/Modules/win/_Winmodule.c
View File

@ -2566,363 +2566,363 @@ static PyObject *WinObj_ShowWindow(WindowObject *_self, PyObject *_args)
static PyMethodDef WinObj_methods[] = {
{"GetWindowOwnerCount", (PyCFunction)WinObj_GetWindowOwnerCount, 1,
"() -> (UInt32 outCount)"},
PyDoc_STR("() -> (UInt32 outCount)")},
{"CloneWindow", (PyCFunction)WinObj_CloneWindow, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#if !TARGET_API_MAC_OS8
{"GetWindowRetainCount", (PyCFunction)WinObj_GetWindowRetainCount, 1,
"() -> (ItemCount _rv)"},
PyDoc_STR("() -> (ItemCount _rv)")},
#endif
#if !TARGET_API_MAC_OS8
{"RetainWindow", (PyCFunction)WinObj_RetainWindow, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
#if !TARGET_API_MAC_OS8
{"ReleaseWindow", (PyCFunction)WinObj_ReleaseWindow, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
#if !TARGET_API_MAC_OS8
{"ReshapeCustomWindow", (PyCFunction)WinObj_ReshapeCustomWindow, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
{"GetWindowWidgetHilite", (PyCFunction)WinObj_GetWindowWidgetHilite, 1,
"() -> (WindowDefPartCode outHilite)"},
PyDoc_STR("() -> (WindowDefPartCode outHilite)")},
{"GetWindowClass", (PyCFunction)WinObj_GetWindowClass, 1,
"() -> (WindowClass outClass)"},
PyDoc_STR("() -> (WindowClass outClass)")},
{"GetWindowAttributes", (PyCFunction)WinObj_GetWindowAttributes, 1,
"() -> (WindowAttributes outAttributes)"},
PyDoc_STR("() -> (WindowAttributes outAttributes)")},
#if !TARGET_API_MAC_OS8
{"ChangeWindowAttributes", (PyCFunction)WinObj_ChangeWindowAttributes, 1,
"(WindowAttributes setTheseAttributes, WindowAttributes clearTheseAttributes) -> None"},
PyDoc_STR("(WindowAttributes setTheseAttributes, WindowAttributes clearTheseAttributes) -> None")},
#endif
#if !TARGET_API_MAC_OS8
{"SetWindowClass", (PyCFunction)WinObj_SetWindowClass, 1,
"(WindowClass inWindowClass) -> None"},
PyDoc_STR("(WindowClass inWindowClass) -> None")},
#endif
#if !TARGET_API_MAC_OS8
{"SetWindowModality", (PyCFunction)WinObj_SetWindowModality, 1,
"(WindowModality inModalKind, WindowPtr inUnavailableWindow) -> None"},
PyDoc_STR("(WindowModality inModalKind, WindowPtr inUnavailableWindow) -> None")},
#endif
#if !TARGET_API_MAC_OS8
{"GetWindowModality", (PyCFunction)WinObj_GetWindowModality, 1,
"() -> (WindowModality outModalKind, WindowPtr outUnavailableWindow)"},
PyDoc_STR("() -> (WindowModality outModalKind, WindowPtr outUnavailableWindow)")},
#endif
#if !TARGET_API_MAC_CARBON
{"SetWinColor", (PyCFunction)WinObj_SetWinColor, 1,
"(WCTabHandle newColorTable) -> None"},
PyDoc_STR("(WCTabHandle newColorTable) -> None")},
#endif
{"SetWindowContentColor", (PyCFunction)WinObj_SetWindowContentColor, 1,
"(RGBColor color) -> None"},
PyDoc_STR("(RGBColor color) -> None")},
{"GetWindowContentColor", (PyCFunction)WinObj_GetWindowContentColor, 1,
"() -> (RGBColor color)"},
PyDoc_STR("() -> (RGBColor color)")},
{"GetWindowContentPattern", (PyCFunction)WinObj_GetWindowContentPattern, 1,
"(PixPatHandle outPixPat) -> None"},
PyDoc_STR("(PixPatHandle outPixPat) -> None")},
{"SetWindowContentPattern", (PyCFunction)WinObj_SetWindowContentPattern, 1,
"(PixPatHandle pixPat) -> None"},
PyDoc_STR("(PixPatHandle pixPat) -> None")},
#if !TARGET_API_MAC_OS8
{"ScrollWindowRect", (PyCFunction)WinObj_ScrollWindowRect, 1,
"(Rect inScrollRect, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None"},
PyDoc_STR("(Rect inScrollRect, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None")},
#endif
#if !TARGET_API_MAC_OS8
{"ScrollWindowRegion", (PyCFunction)WinObj_ScrollWindowRegion, 1,
"(RgnHandle inScrollRgn, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None"},
PyDoc_STR("(RgnHandle inScrollRgn, SInt16 inHPixels, SInt16 inVPixels, ScrollWindowOptions inOptions, RgnHandle outExposedRgn) -> None")},
#endif
{"ClipAbove", (PyCFunction)WinObj_ClipAbove, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#if !TARGET_API_MAC_CARBON
{"SaveOld", (PyCFunction)WinObj_SaveOld, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
#if !TARGET_API_MAC_CARBON
{"DrawNew", (PyCFunction)WinObj_DrawNew, 1,
"(Boolean update) -> None"},
PyDoc_STR("(Boolean update) -> None")},
#endif
{"PaintOne", (PyCFunction)WinObj_PaintOne, 1,
"(RgnHandle clobberedRgn) -> None"},
PyDoc_STR("(RgnHandle clobberedRgn) -> None")},
{"PaintBehind", (PyCFunction)WinObj_PaintBehind, 1,
"(RgnHandle clobberedRgn) -> None"},
PyDoc_STR("(RgnHandle clobberedRgn) -> None")},
{"CalcVis", (PyCFunction)WinObj_CalcVis, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"CalcVisBehind", (PyCFunction)WinObj_CalcVisBehind, 1,
"(RgnHandle clobberedRgn) -> None"},
PyDoc_STR("(RgnHandle clobberedRgn) -> None")},
{"BringToFront", (PyCFunction)WinObj_BringToFront, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"SendBehind", (PyCFunction)WinObj_SendBehind, 1,
"(WindowPtr behindWindow) -> None"},
PyDoc_STR("(WindowPtr behindWindow) -> None")},
{"SelectWindow", (PyCFunction)WinObj_SelectWindow, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#if !TARGET_API_MAC_OS8
{"GetNextWindowOfClass", (PyCFunction)WinObj_GetNextWindowOfClass, 1,
"(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)"},
PyDoc_STR("(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)")},
#endif
#if !TARGET_API_MAC_OS8
{"SetWindowAlternateTitle", (PyCFunction)WinObj_SetWindowAlternateTitle, 1,
"(CFStringRef inTitle) -> None"},
PyDoc_STR("(CFStringRef inTitle) -> None")},
#endif
#if !TARGET_API_MAC_OS8
{"CopyWindowAlternateTitle", (PyCFunction)WinObj_CopyWindowAlternateTitle, 1,
"() -> (CFStringRef outTitle)"},
PyDoc_STR("() -> (CFStringRef outTitle)")},
#endif
#if !TARGET_API_MAC_CARBON
{"IsValidWindowPtr", (PyCFunction)WinObj_IsValidWindowPtr, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
#endif
{"HiliteWindow", (PyCFunction)WinObj_HiliteWindow, 1,
"(Boolean fHilite) -> None"},
PyDoc_STR("(Boolean fHilite) -> None")},
{"SetWRefCon", (PyCFunction)WinObj_SetWRefCon, 1,
"(long data) -> None"},
PyDoc_STR("(long data) -> None")},
{"GetWRefCon", (PyCFunction)WinObj_GetWRefCon, 1,
"() -> (long _rv)"},
PyDoc_STR("() -> (long _rv)")},
{"SetWindowPic", (PyCFunction)WinObj_SetWindowPic, 1,
"(PicHandle pic) -> None"},
PyDoc_STR("(PicHandle pic) -> None")},
{"GetWindowPic", (PyCFunction)WinObj_GetWindowPic, 1,
"() -> (PicHandle _rv)"},
PyDoc_STR("() -> (PicHandle _rv)")},
{"GetWVariant", (PyCFunction)WinObj_GetWVariant, 1,
"() -> (short _rv)"},
PyDoc_STR("() -> (short _rv)")},
{"GetWindowFeatures", (PyCFunction)WinObj_GetWindowFeatures, 1,
"() -> (UInt32 outFeatures)"},
PyDoc_STR("() -> (UInt32 outFeatures)")},
{"GetWindowRegion", (PyCFunction)WinObj_GetWindowRegion, 1,
"(WindowRegionCode inRegionCode, RgnHandle ioWinRgn) -> None"},
PyDoc_STR("(WindowRegionCode inRegionCode, RgnHandle ioWinRgn) -> None")},
{"GetWindowStructureWidths", (PyCFunction)WinObj_GetWindowStructureWidths, 1,
"() -> (Rect outRect)"},
PyDoc_STR("() -> (Rect outRect)")},
{"BeginUpdate", (PyCFunction)WinObj_BeginUpdate, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"EndUpdate", (PyCFunction)WinObj_EndUpdate, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"InvalWindowRgn", (PyCFunction)WinObj_InvalWindowRgn, 1,
"(RgnHandle region) -> None"},
PyDoc_STR("(RgnHandle region) -> None")},
{"InvalWindowRect", (PyCFunction)WinObj_InvalWindowRect, 1,
"(Rect bounds) -> None"},
PyDoc_STR("(Rect bounds) -> None")},
{"ValidWindowRgn", (PyCFunction)WinObj_ValidWindowRgn, 1,
"(RgnHandle region) -> None"},
PyDoc_STR("(RgnHandle region) -> None")},
{"ValidWindowRect", (PyCFunction)WinObj_ValidWindowRect, 1,
"(Rect bounds) -> None"},
PyDoc_STR("(Rect bounds) -> None")},
{"DrawGrowIcon", (PyCFunction)WinObj_DrawGrowIcon, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"SetWTitle", (PyCFunction)WinObj_SetWTitle, 1,
"(Str255 title) -> None"},
PyDoc_STR("(Str255 title) -> None")},
{"GetWTitle", (PyCFunction)WinObj_GetWTitle, 1,
"() -> (Str255 title)"},
PyDoc_STR("() -> (Str255 title)")},
#if !TARGET_API_MAC_OS8
{"SetWindowTitleWithCFString", (PyCFunction)WinObj_SetWindowTitleWithCFString, 1,
"(CFStringRef inString) -> None"},
PyDoc_STR("(CFStringRef inString) -> None")},
#endif
#if !TARGET_API_MAC_OS8
{"CopyWindowTitleAsCFString", (PyCFunction)WinObj_CopyWindowTitleAsCFString, 1,
"() -> (CFStringRef outString)"},
PyDoc_STR("() -> (CFStringRef outString)")},
#endif
{"SetWindowProxyFSSpec", (PyCFunction)WinObj_SetWindowProxyFSSpec, 1,
"(FSSpec inFile) -> None"},
PyDoc_STR("(FSSpec inFile) -> None")},
{"GetWindowProxyFSSpec", (PyCFunction)WinObj_GetWindowProxyFSSpec, 1,
"() -> (FSSpec outFile)"},
PyDoc_STR("() -> (FSSpec outFile)")},
{"SetWindowProxyAlias", (PyCFunction)WinObj_SetWindowProxyAlias, 1,
"(AliasHandle alias) -> None"},
PyDoc_STR("(AliasHandle alias) -> None")},
{"GetWindowProxyAlias", (PyCFunction)WinObj_GetWindowProxyAlias, 1,
"() -> (AliasHandle alias)"},
PyDoc_STR("() -> (AliasHandle alias)")},
{"SetWindowProxyCreatorAndType", (PyCFunction)WinObj_SetWindowProxyCreatorAndType, 1,
"(OSType fileCreator, OSType fileType, SInt16 vRefNum) -> None"},
PyDoc_STR("(OSType fileCreator, OSType fileType, SInt16 vRefNum) -> None")},
{"GetWindowProxyIcon", (PyCFunction)WinObj_GetWindowProxyIcon, 1,
"() -> (IconRef outIcon)"},
PyDoc_STR("() -> (IconRef outIcon)")},
{"SetWindowProxyIcon", (PyCFunction)WinObj_SetWindowProxyIcon, 1,
"(IconRef icon) -> None"},
PyDoc_STR("(IconRef icon) -> None")},
{"RemoveWindowProxy", (PyCFunction)WinObj_RemoveWindowProxy, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"BeginWindowProxyDrag", (PyCFunction)WinObj_BeginWindowProxyDrag, 1,
"(RgnHandle outDragOutlineRgn) -> (DragReference outNewDrag)"},
PyDoc_STR("(RgnHandle outDragOutlineRgn) -> (DragReference outNewDrag)")},
{"EndWindowProxyDrag", (PyCFunction)WinObj_EndWindowProxyDrag, 1,
"(DragReference theDrag) -> None"},
PyDoc_STR("(DragReference theDrag) -> None")},
{"TrackWindowProxyFromExistingDrag", (PyCFunction)WinObj_TrackWindowProxyFromExistingDrag, 1,
"(Point startPt, DragReference drag, RgnHandle inDragOutlineRgn) -> None"},
PyDoc_STR("(Point startPt, DragReference drag, RgnHandle inDragOutlineRgn) -> None")},
{"TrackWindowProxyDrag", (PyCFunction)WinObj_TrackWindowProxyDrag, 1,
"(Point startPt) -> None"},
PyDoc_STR("(Point startPt) -> None")},
{"IsWindowModified", (PyCFunction)WinObj_IsWindowModified, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
{"SetWindowModified", (PyCFunction)WinObj_SetWindowModified, 1,
"(Boolean modified) -> None"},
PyDoc_STR("(Boolean modified) -> None")},
{"IsWindowPathSelectClick", (PyCFunction)WinObj_IsWindowPathSelectClick, 1,
"(EventRecord event) -> (Boolean _rv)"},
PyDoc_STR("(EventRecord event) -> (Boolean _rv)")},
{"WindowPathSelect", (PyCFunction)WinObj_WindowPathSelect, 1,
"(MenuHandle menu) -> (SInt32 outMenuResult)"},
PyDoc_STR("(MenuHandle menu) -> (SInt32 outMenuResult)")},
{"HiliteWindowFrameForDrag", (PyCFunction)WinObj_HiliteWindowFrameForDrag, 1,
"(Boolean hilited) -> None"},
PyDoc_STR("(Boolean hilited) -> None")},
{"TransitionWindow", (PyCFunction)WinObj_TransitionWindow, 1,
"(WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None"},
PyDoc_STR("(WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None")},
#if TARGET_API_MAC_OSX
{"TransitionWindowAndParent", (PyCFunction)WinObj_TransitionWindowAndParent, 1,
"(WindowPtr parentWindow, WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None"},
PyDoc_STR("(WindowPtr parentWindow, WindowTransitionEffect effect, WindowTransitionAction action, Rect rect) -> None")},
#endif
{"MacMoveWindow", (PyCFunction)WinObj_MacMoveWindow, 1,
"(short hGlobal, short vGlobal, Boolean front) -> None"},
PyDoc_STR("(short hGlobal, short vGlobal, Boolean front) -> None")},
{"SizeWindow", (PyCFunction)WinObj_SizeWindow, 1,
"(short w, short h, Boolean fUpdate) -> None"},
PyDoc_STR("(short w, short h, Boolean fUpdate) -> None")},
{"GrowWindow", (PyCFunction)WinObj_GrowWindow, 1,
"(Point startPt, Rect bBox) -> (long _rv)"},
PyDoc_STR("(Point startPt, Rect bBox) -> (long _rv)")},
{"DragWindow", (PyCFunction)WinObj_DragWindow, 1,
"(Point startPt, Rect boundsRect) -> None"},
PyDoc_STR("(Point startPt, Rect boundsRect) -> None")},
{"ZoomWindow", (PyCFunction)WinObj_ZoomWindow, 1,
"(WindowPartCode partCode, Boolean front) -> None"},
PyDoc_STR("(WindowPartCode partCode, Boolean front) -> None")},
{"IsWindowCollapsable", (PyCFunction)WinObj_IsWindowCollapsable, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
{"IsWindowCollapsed", (PyCFunction)WinObj_IsWindowCollapsed, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
{"CollapseWindow", (PyCFunction)WinObj_CollapseWindow, 1,
"(Boolean collapse) -> None"},
PyDoc_STR("(Boolean collapse) -> None")},
{"GetWindowBounds", (PyCFunction)WinObj_GetWindowBounds, 1,
"(WindowRegionCode regionCode) -> (Rect globalBounds)"},
PyDoc_STR("(WindowRegionCode regionCode) -> (Rect globalBounds)")},
{"ResizeWindow", (PyCFunction)WinObj_ResizeWindow, 1,
"(Point startPoint, Rect sizeConstraints) -> (Boolean _rv, Rect newContentRect)"},
PyDoc_STR("(Point startPoint, Rect sizeConstraints) -> (Boolean _rv, Rect newContentRect)")},
{"SetWindowBounds", (PyCFunction)WinObj_SetWindowBounds, 1,
"(WindowRegionCode regionCode, Rect globalBounds) -> None"},
PyDoc_STR("(WindowRegionCode regionCode, Rect globalBounds) -> None")},
{"RepositionWindow", (PyCFunction)WinObj_RepositionWindow, 1,
"(WindowPtr parentWindow, WindowPositionMethod method) -> None"},
PyDoc_STR("(WindowPtr parentWindow, WindowPositionMethod method) -> None")},
{"MoveWindowStructure", (PyCFunction)WinObj_MoveWindowStructure, 1,
"(short hGlobal, short vGlobal) -> None"},
PyDoc_STR("(short hGlobal, short vGlobal) -> None")},
{"IsWindowInStandardState", (PyCFunction)WinObj_IsWindowInStandardState, 1,
"() -> (Boolean _rv, Point idealSize, Rect idealStandardState)"},
PyDoc_STR("() -> (Boolean _rv, Point idealSize, Rect idealStandardState)")},
{"ZoomWindowIdeal", (PyCFunction)WinObj_ZoomWindowIdeal, 1,
"(WindowPartCode partCode) -> (Point ioIdealSize)"},
PyDoc_STR("(WindowPartCode partCode) -> (Point ioIdealSize)")},
{"GetWindowIdealUserState", (PyCFunction)WinObj_GetWindowIdealUserState, 1,
"() -> (Rect userState)"},
PyDoc_STR("() -> (Rect userState)")},
{"SetWindowIdealUserState", (PyCFunction)WinObj_SetWindowIdealUserState, 1,
"(Rect userState) -> None"},
PyDoc_STR("(Rect userState) -> None")},
#if !TARGET_API_MAC_OS8
{"GetWindowGreatestAreaDevice", (PyCFunction)WinObj_GetWindowGreatestAreaDevice, 1,
"(WindowRegionCode inRegion) -> (GDHandle outGreatestDevice, Rect outGreatestDeviceRect)"},
PyDoc_STR("(WindowRegionCode inRegion) -> (GDHandle outGreatestDevice, Rect outGreatestDeviceRect)")},
#endif
#if !TARGET_API_MAC_OS8
{"ConstrainWindowToScreen", (PyCFunction)WinObj_ConstrainWindowToScreen, 1,
"(WindowRegionCode inRegionCode, WindowConstrainOptions inOptions, Rect inScreenRect) -> (Rect outStructure)"},
PyDoc_STR("(WindowRegionCode inRegionCode, WindowConstrainOptions inOptions, Rect inScreenRect) -> (Rect outStructure)")},
#endif
{"HideWindow", (PyCFunction)WinObj_HideWindow, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"MacShowWindow", (PyCFunction)WinObj_MacShowWindow, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"ShowHide", (PyCFunction)WinObj_ShowHide, 1,
"(Boolean showFlag) -> None"},
PyDoc_STR("(Boolean showFlag) -> None")},
{"MacIsWindowVisible", (PyCFunction)WinObj_MacIsWindowVisible, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
#if !TARGET_API_MAC_OS8
{"ShowSheetWindow", (PyCFunction)WinObj_ShowSheetWindow, 1,
"(WindowPtr inParentWindow) -> None"},
PyDoc_STR("(WindowPtr inParentWindow) -> None")},
#endif
#if !TARGET_API_MAC_OS8
{"HideSheetWindow", (PyCFunction)WinObj_HideSheetWindow, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
#if !TARGET_API_MAC_OS8
{"GetSheetWindowParent", (PyCFunction)WinObj_GetSheetWindowParent, 1,
"() -> (WindowPtr outParentWindow)"},
PyDoc_STR("() -> (WindowPtr outParentWindow)")},
#endif
#if !TARGET_API_MAC_OS8
{"GetWindowPropertyAttributes", (PyCFunction)WinObj_GetWindowPropertyAttributes, 1,
"(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)"},
PyDoc_STR("(OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)")},
#endif
#if !TARGET_API_MAC_OS8
{"ChangeWindowPropertyAttributes", (PyCFunction)WinObj_ChangeWindowPropertyAttributes, 1,
"(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None"},
PyDoc_STR("(OSType propertyCreator, OSType propertyTag, UInt32 attributesToSet, UInt32 attributesToClear) -> None")},
#endif
{"TrackBox", (PyCFunction)WinObj_TrackBox, 1,
"(Point thePt, WindowPartCode partCode) -> (Boolean _rv)"},
PyDoc_STR("(Point thePt, WindowPartCode partCode) -> (Boolean _rv)")},
{"TrackGoAway", (PyCFunction)WinObj_TrackGoAway, 1,
"(Point thePt) -> (Boolean _rv)"},
PyDoc_STR("(Point thePt) -> (Boolean _rv)")},
#if !TARGET_API_MAC_CARBON
{"GetAuxWin", (PyCFunction)WinObj_GetAuxWin, 1,
"() -> (Boolean _rv, AuxWinHandle awHndl)"},
PyDoc_STR("() -> (Boolean _rv, AuxWinHandle awHndl)")},
#endif
#if !TARGET_API_MAC_CARBON
{"GetWindowGoAwayFlag", (PyCFunction)WinObj_GetWindowGoAwayFlag, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
#endif
#if !TARGET_API_MAC_CARBON
{"GetWindowSpareFlag", (PyCFunction)WinObj_GetWindowSpareFlag, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
#endif
{"GetWindowPort", (PyCFunction)WinObj_GetWindowPort, 1,
"() -> (CGrafPtr _rv)"},
PyDoc_STR("() -> (CGrafPtr _rv)")},
{"GetWindowKind", (PyCFunction)WinObj_GetWindowKind, 1,
"() -> (short _rv)"},
PyDoc_STR("() -> (short _rv)")},
{"IsWindowHilited", (PyCFunction)WinObj_IsWindowHilited, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
#if !TARGET_API_MAC_OS8
{"IsWindowUpdatePending", (PyCFunction)WinObj_IsWindowUpdatePending, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
#endif
{"MacGetNextWindow", (PyCFunction)WinObj_MacGetNextWindow, 1,
"() -> (WindowPtr _rv)"},
PyDoc_STR("() -> (WindowPtr _rv)")},
{"GetWindowStandardState", (PyCFunction)WinObj_GetWindowStandardState, 1,
"() -> (Rect rect)"},
PyDoc_STR("() -> (Rect rect)")},
{"GetWindowUserState", (PyCFunction)WinObj_GetWindowUserState, 1,
"() -> (Rect rect)"},
PyDoc_STR("() -> (Rect rect)")},
{"SetWindowKind", (PyCFunction)WinObj_SetWindowKind, 1,
"(short kind) -> None"},
PyDoc_STR("(short kind) -> None")},
{"SetWindowStandardState", (PyCFunction)WinObj_SetWindowStandardState, 1,
"(Rect rect) -> None"},
PyDoc_STR("(Rect rect) -> None")},
{"SetWindowUserState", (PyCFunction)WinObj_SetWindowUserState, 1,
"(Rect rect) -> None"},
PyDoc_STR("(Rect rect) -> None")},
{"SetPortWindowPort", (PyCFunction)WinObj_SetPortWindowPort, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"GetWindowPortBounds", (PyCFunction)WinObj_GetWindowPortBounds, 1,
"() -> (Rect bounds)"},
PyDoc_STR("() -> (Rect bounds)")},
{"IsWindowVisible", (PyCFunction)WinObj_IsWindowVisible, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
#if !TARGET_API_MAC_CARBON
{"GetWindowZoomFlag", (PyCFunction)WinObj_GetWindowZoomFlag, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
#endif
{"GetWindowStructureRgn", (PyCFunction)WinObj_GetWindowStructureRgn, 1,
"(RgnHandle r) -> None"},
PyDoc_STR("(RgnHandle r) -> None")},
{"GetWindowContentRgn", (PyCFunction)WinObj_GetWindowContentRgn, 1,
"(RgnHandle r) -> None"},
PyDoc_STR("(RgnHandle r) -> None")},
{"GetWindowUpdateRgn", (PyCFunction)WinObj_GetWindowUpdateRgn, 1,
"(RgnHandle r) -> None"},
PyDoc_STR("(RgnHandle r) -> None")},
#if !TARGET_API_MAC_CARBON
{"GetWindowTitleWidth", (PyCFunction)WinObj_GetWindowTitleWidth, 1,
"() -> (short _rv)"},
PyDoc_STR("() -> (short _rv)")},
#endif
{"GetNextWindow", (PyCFunction)WinObj_GetNextWindow, 1,
"() -> (WindowPtr _rv)"},
PyDoc_STR("() -> (WindowPtr _rv)")},
#if !TARGET_API_MAC_CARBON
{"CloseWindow", (PyCFunction)WinObj_CloseWindow, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
{"MoveWindow", (PyCFunction)WinObj_MoveWindow, 1,
"(short hGlobal, short vGlobal, Boolean front) -> None"},
PyDoc_STR("(short hGlobal, short vGlobal, Boolean front) -> None")},
{"ShowWindow", (PyCFunction)WinObj_ShowWindow, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{NULL, NULL, 0}
};
@ -3658,118 +3658,118 @@ static PyObject *Win_FindWindow(PyObject *_self, PyObject *_args)
static PyMethodDef Win_methods[] = {
{"GetNewCWindow", (PyCFunction)Win_GetNewCWindow, 1,
"(short windowID, WindowPtr behind) -> (WindowPtr _rv)"},
PyDoc_STR("(short windowID, WindowPtr behind) -> (WindowPtr _rv)")},
{"NewWindow", (PyCFunction)Win_NewWindow, 1,
"(Rect boundsRect, Str255 title, Boolean visible, short theProc, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)"},
PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, short theProc, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)")},
{"GetNewWindow", (PyCFunction)Win_GetNewWindow, 1,
"(short windowID, WindowPtr behind) -> (WindowPtr _rv)"},
PyDoc_STR("(short windowID, WindowPtr behind) -> (WindowPtr _rv)")},
{"NewCWindow", (PyCFunction)Win_NewCWindow, 1,
"(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)"},
PyDoc_STR("(Rect boundsRect, Str255 title, Boolean visible, short procID, WindowPtr behind, Boolean goAwayFlag, long refCon) -> (WindowPtr _rv)")},
{"CreateNewWindow", (PyCFunction)Win_CreateNewWindow, 1,
"(WindowClass windowClass, WindowAttributes attributes, Rect contentBounds) -> (WindowPtr outWindow)"},
PyDoc_STR("(WindowClass windowClass, WindowAttributes attributes, Rect contentBounds) -> (WindowPtr outWindow)")},
{"CreateWindowFromResource", (PyCFunction)Win_CreateWindowFromResource, 1,
"(SInt16 resID) -> (WindowPtr outWindow)"},
PyDoc_STR("(SInt16 resID) -> (WindowPtr outWindow)")},
{"ShowFloatingWindows", (PyCFunction)Win_ShowFloatingWindows, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"HideFloatingWindows", (PyCFunction)Win_HideFloatingWindows, 1,
"() -> None"},
PyDoc_STR("() -> None")},
{"AreFloatingWindowsVisible", (PyCFunction)Win_AreFloatingWindowsVisible, 1,
"() -> (Boolean _rv)"},
PyDoc_STR("() -> (Boolean _rv)")},
#if !TARGET_API_MAC_CARBON
{"SetDeskCPat", (PyCFunction)Win_SetDeskCPat, 1,
"(PixPatHandle deskPixPat) -> None"},
PyDoc_STR("(PixPatHandle deskPixPat) -> None")},
#endif
{"CheckUpdate", (PyCFunction)Win_CheckUpdate, 1,
"() -> (Boolean _rv, EventRecord theEvent)"},
PyDoc_STR("() -> (Boolean _rv, EventRecord theEvent)")},
{"MacFindWindow", (PyCFunction)Win_MacFindWindow, 1,
"(Point thePoint) -> (WindowPartCode _rv, WindowPtr window)"},
PyDoc_STR("(Point thePoint) -> (WindowPartCode _rv, WindowPtr window)")},
{"FrontWindow", (PyCFunction)Win_FrontWindow, 1,
"() -> (WindowPtr _rv)"},
PyDoc_STR("() -> (WindowPtr _rv)")},
{"FrontNonFloatingWindow", (PyCFunction)Win_FrontNonFloatingWindow, 1,
"() -> (WindowPtr _rv)"},
PyDoc_STR("() -> (WindowPtr _rv)")},
#if !TARGET_API_MAC_OS8
{"GetFrontWindowOfClass", (PyCFunction)Win_GetFrontWindowOfClass, 1,
"(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)"},
PyDoc_STR("(WindowClass inWindowClass, Boolean mustBeVisible) -> (WindowPtr _rv)")},
#endif
#if !TARGET_API_MAC_OS8
{"FindWindowOfClass", (PyCFunction)Win_FindWindowOfClass, 1,
"(Point where, WindowClass inWindowClass) -> (WindowPtr outWindow, WindowPartCode outWindowPart)"},
PyDoc_STR("(Point where, WindowClass inWindowClass) -> (WindowPtr outWindow, WindowPartCode outWindowPart)")},
#endif
#if !TARGET_API_MAC_OS8
{"CreateStandardWindowMenu", (PyCFunction)Win_CreateStandardWindowMenu, 1,
"(OptionBits inOptions) -> (MenuHandle outMenu)"},
PyDoc_STR("(OptionBits inOptions) -> (MenuHandle outMenu)")},
#endif
#if !TARGET_API_MAC_CARBON
{"InitWindows", (PyCFunction)Win_InitWindows, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
#if !TARGET_API_MAC_CARBON
{"GetWMgrPort", (PyCFunction)Win_GetWMgrPort, 1,
"() -> (GrafPtr wPort)"},
PyDoc_STR("() -> (GrafPtr wPort)")},
#endif
#if !TARGET_API_MAC_CARBON
{"GetCWMgrPort", (PyCFunction)Win_GetCWMgrPort, 1,
"() -> (CGrafPtr wMgrCPort)"},
PyDoc_STR("() -> (CGrafPtr wMgrCPort)")},
#endif
#if !TARGET_API_MAC_CARBON
{"InitFloatingWindows", (PyCFunction)Win_InitFloatingWindows, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
#if !TARGET_API_MAC_CARBON
{"InvalRect", (PyCFunction)Win_InvalRect, 1,
"(Rect badRect) -> None"},
PyDoc_STR("(Rect badRect) -> None")},
#endif
#if !TARGET_API_MAC_CARBON
{"InvalRgn", (PyCFunction)Win_InvalRgn, 1,
"(RgnHandle badRgn) -> None"},
PyDoc_STR("(RgnHandle badRgn) -> None")},
#endif
#if !TARGET_API_MAC_CARBON
{"ValidRect", (PyCFunction)Win_ValidRect, 1,
"(Rect goodRect) -> None"},
PyDoc_STR("(Rect goodRect) -> None")},
#endif
#if !TARGET_API_MAC_CARBON
{"ValidRgn", (PyCFunction)Win_ValidRgn, 1,
"(RgnHandle goodRgn) -> None"},
PyDoc_STR("(RgnHandle goodRgn) -> None")},
#endif
{"CollapseAllWindows", (PyCFunction)Win_CollapseAllWindows, 1,
"(Boolean collapse) -> None"},
PyDoc_STR("(Boolean collapse) -> None")},
#if !TARGET_API_MAC_OS8
{"GetAvailableWindowPositioningBounds", (PyCFunction)Win_GetAvailableWindowPositioningBounds, 1,
"(GDHandle inDevice) -> (Rect availableRect)"},
PyDoc_STR("(GDHandle inDevice) -> (Rect availableRect)")},
#endif
#if !TARGET_API_MAC_OS8
{"DisableScreenUpdates", (PyCFunction)Win_DisableScreenUpdates, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
#if !TARGET_API_MAC_OS8
{"EnableScreenUpdates", (PyCFunction)Win_EnableScreenUpdates, 1,
"() -> None"},
PyDoc_STR("() -> None")},
#endif
{"PinRect", (PyCFunction)Win_PinRect, 1,
"(Rect theRect, Point thePt) -> (long _rv)"},
PyDoc_STR("(Rect theRect, Point thePt) -> (long _rv)")},
{"GetGrayRgn", (PyCFunction)Win_GetGrayRgn, 1,
"() -> (RgnHandle _rv)"},
PyDoc_STR("() -> (RgnHandle _rv)")},
{"GetWindowFromPort", (PyCFunction)Win_GetWindowFromPort, 1,
"(CGrafPtr port) -> (WindowPtr _rv)"},
PyDoc_STR("(CGrafPtr port) -> (WindowPtr _rv)")},
{"WhichWindow", (PyCFunction)Win_WhichWindow, 1,
"Resolve an integer WindowPtr address to a Window object"},
PyDoc_STR("Resolve an integer WindowPtr address to a Window object")},
{"FindWindow", (PyCFunction)Win_FindWindow, 1,
"(Point thePoint) -> (short _rv, WindowPtr theWindow)"},
PyDoc_STR("(Point thePoint) -> (short _rv, WindowPtr theWindow)")},
{NULL, NULL, 0}
};