Should finally fix 531398. 2.2.1 candidate.
Also blacklisted some constants with definitions that were not Python-compatible.
OSErr _err;
DescType toType;
AEDesc result;
+#ifndef AECoerceDesc
+ PyMac_PRECHECK(AECoerceDesc);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetOSType, &toType))
return NULL;
PyObject *_res = NULL;
OSErr _err;
AEDesc result;
+#ifndef AEDuplicateDesc
+ PyMac_PRECHECK(AEDuplicateDesc);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = AEDuplicateDesc(&_self->ob_itself,
PyObject *_res = NULL;
OSErr _err;
long theCount;
+#ifndef AECountItems
+ PyMac_PRECHECK(AECountItems);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = AECountItems(&_self->ob_itself,
char *dataPtr__in__;
long dataPtr__len__;
int dataPtr__in_len__;
+#ifndef AEPutPtr
+ PyMac_PRECHECK(AEPutPtr);
+#endif
if (!PyArg_ParseTuple(_args, "lO&s#",
&index,
PyMac_GetOSType, &typeCode,
OSErr _err;
long index;
AEDesc theAEDesc;
+#ifndef AEPutDesc
+ PyMac_PRECHECK(AEPutDesc);
+#endif
if (!PyArg_ParseTuple(_args, "lO&",
&index,
AEDesc_Convert, &theAEDesc))
char *dataPtr__out__;
long dataPtr__len__;
int dataPtr__in_len__;
+#ifndef AEGetNthPtr
+ PyMac_PRECHECK(AEGetNthPtr);
+#endif
if (!PyArg_ParseTuple(_args, "lO&i",
&index,
PyMac_GetOSType, &desiredType,
DescType desiredType;
AEKeyword theAEKeyword;
AEDesc result;
+#ifndef AEGetNthDesc
+ PyMac_PRECHECK(AEGetNthDesc);
+#endif
if (!PyArg_ParseTuple(_args, "lO&",
&index,
PyMac_GetOSType, &desiredType))
long index;
DescType typeCode;
Size dataSize;
+#ifndef AESizeOfNthItem
+ PyMac_PRECHECK(AESizeOfNthItem);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&index))
return NULL;
PyObject *_res = NULL;
OSErr _err;
long index;
+#ifndef AEDeleteItem
+ PyMac_PRECHECK(AEDeleteItem);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&index))
return NULL;
char *dataPtr__in__;
long dataPtr__len__;
int dataPtr__in_len__;
+#ifndef AEPutParamPtr
+ PyMac_PRECHECK(AEPutParamPtr);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&s#",
PyMac_GetOSType, &theAEKeyword,
PyMac_GetOSType, &typeCode,
OSErr _err;
AEKeyword theAEKeyword;
AEDesc theAEDesc;
+#ifndef AEPutParamDesc
+ PyMac_PRECHECK(AEPutParamDesc);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetOSType, &theAEKeyword,
AEDesc_Convert, &theAEDesc))
char *dataPtr__out__;
long dataPtr__len__;
int dataPtr__in_len__;
+#ifndef AEGetParamPtr
+ PyMac_PRECHECK(AEGetParamPtr);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&i",
PyMac_GetOSType, &theAEKeyword,
PyMac_GetOSType, &desiredType,
AEKeyword theAEKeyword;
DescType desiredType;
AEDesc result;
+#ifndef AEGetParamDesc
+ PyMac_PRECHECK(AEGetParamDesc);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetOSType, &theAEKeyword,
PyMac_GetOSType, &desiredType))
AEKeyword theAEKeyword;
DescType typeCode;
Size dataSize;
+#ifndef AESizeOfParam
+ PyMac_PRECHECK(AESizeOfParam);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetOSType, &theAEKeyword))
return NULL;
PyObject *_res = NULL;
OSErr _err;
AEKeyword theAEKeyword;
+#ifndef AEDeleteParam
+ PyMac_PRECHECK(AEDeleteParam);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetOSType, &theAEKeyword))
return NULL;
char *dataPtr__out__;
long dataPtr__len__;
int dataPtr__in_len__;
+#ifndef AEGetAttributePtr
+ PyMac_PRECHECK(AEGetAttributePtr);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&i",
PyMac_GetOSType, &theAEKeyword,
PyMac_GetOSType, &desiredType,
AEKeyword theAEKeyword;
DescType desiredType;
AEDesc result;
+#ifndef AEGetAttributeDesc
+ PyMac_PRECHECK(AEGetAttributeDesc);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetOSType, &theAEKeyword,
PyMac_GetOSType, &desiredType))
AEKeyword theAEKeyword;
DescType typeCode;
Size dataSize;
+#ifndef AESizeOfAttribute
+ PyMac_PRECHECK(AESizeOfAttribute);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetOSType, &theAEKeyword))
return NULL;
char *dataPtr__in__;
long dataPtr__len__;
int dataPtr__in_len__;
+#ifndef AEPutAttributePtr
+ PyMac_PRECHECK(AEPutAttributePtr);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&s#",
PyMac_GetOSType, &theAEKeyword,
PyMac_GetOSType, &typeCode,
OSErr _err;
AEKeyword theAEKeyword;
AEDesc theAEDesc;
+#ifndef AEPutAttributeDesc
+ PyMac_PRECHECK(AEPutAttributeDesc);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetOSType, &theAEKeyword,
AEDesc_Convert, &theAEDesc))
{
PyObject *_res = NULL;
Size _rv;
+#ifndef AEGetDescDataSize
+ PyMac_PRECHECK(AEGetDescDataSize);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = AEGetDescDataSize(&_self->ob_itself);
AESendMode sendMode;
AESendPriority sendPriority;
long timeOutInTicks;
+#ifndef AESend
+ PyMac_PRECHECK(AESend);
+#endif
if (!PyArg_ParseTuple(_args, "lhl",
&sendMode,
&sendPriority,
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef AEResetTimer
+ PyMac_PRECHECK(AEResetTimer);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = AEResetTimer(&_self->ob_itself);
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef AESuspendTheCurrentEvent
+ PyMac_PRECHECK(AESuspendTheCurrentEvent);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = AESuspendTheCurrentEvent(&_self->ob_itself);
AppleEvent reply;
AEEventHandlerUPP dispatcher__proc__ = upp_GenericEventHandler;
PyObject *dispatcher;
+#ifndef AEResumeTheCurrentEvent
+ PyMac_PRECHECK(AEResumeTheCurrentEvent);
+#endif
if (!PyArg_ParseTuple(_args, "O&O",
AEDesc_Convert, &reply,
&dispatcher))
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef AEGetTheCurrentEvent
+ PyMac_PRECHECK(AEGetTheCurrentEvent);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = AEGetTheCurrentEvent(&_self->ob_itself);
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef AESetTheCurrentEvent
+ PyMac_PRECHECK(AESetTheCurrentEvent);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = AESetTheCurrentEvent(&_self->ob_itself);
OSErr _err;
short callbackFlags;
AEDesc theToken;
+#ifndef AEResolve
+ PyMac_PRECHECK(AEResolve);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&callbackFlags))
return NULL;
int dataPtr__in_len__;
DescType toType;
AEDesc result;
+#ifndef AECoercePtr
+ PyMac_PRECHECK(AECoercePtr);
+#endif
if (!PyArg_ParseTuple(_args, "O&s#O&",
PyMac_GetOSType, &typeCode,
&dataPtr__in__, &dataPtr__in_len__,
long dataPtr__len__;
int dataPtr__in_len__;
AEDesc result;
+#ifndef AECreateDesc
+ PyMac_PRECHECK(AECreateDesc);
+#endif
if (!PyArg_ParseTuple(_args, "O&s#",
PyMac_GetOSType, &typeCode,
&dataPtr__in__, &dataPtr__in_len__))
int factoringPtr__in_len__;
Boolean isRecord;
AEDescList resultList;
+#ifndef AECreateList
+ PyMac_PRECHECK(AECreateList);
+#endif
if (!PyArg_ParseTuple(_args, "s#b",
&factoringPtr__in__, &factoringPtr__in_len__,
&isRecord))
AEReturnID returnID;
AETransactionID transactionID;
AppleEvent result;
+#ifndef AECreateAppleEvent
+ PyMac_PRECHECK(AECreateAppleEvent);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&hl",
PyMac_GetOSType, &theAEEventClass,
PyMac_GetOSType, &theAEEventID,
long dataPtr__len__;
int dataPtr__in_len__;
AEDesc theAEDesc;
+#ifndef AEReplaceDescData
+ PyMac_PRECHECK(AEReplaceDescData);
+#endif
if (!PyArg_ParseTuple(_args, "O&s#",
PyMac_GetOSType, &typeCode,
&dataPtr__in__, &dataPtr__in_len__))
PyObject *_res = NULL;
OSErr _err;
EventRecord theEventRecord;
+#ifndef AEProcessAppleEvent
+ PyMac_PRECHECK(AEProcessAppleEvent);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetEventRecord, &theEventRecord))
return NULL;
PyObject *_res = NULL;
OSErr _err;
AEInteractAllowed level;
+#ifndef AEGetInteractionAllowed
+ PyMac_PRECHECK(AEGetInteractionAllowed);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = AEGetInteractionAllowed(&level);
PyObject *_res = NULL;
OSErr _err;
AEInteractAllowed level;
+#ifndef AESetInteractionAllowed
+ PyMac_PRECHECK(AESetInteractionAllowed);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&level))
return NULL;
PyObject *_res = NULL;
OSErr _err;
long timeOutInTicks;
+#ifndef AEInteractWithUser
+ PyMac_PRECHECK(AEInteractWithUser);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&timeOutInTicks))
return NULL;
AEEventID theAEEventID;
AEEventHandlerUPP handler__proc__ = upp_GenericEventHandler;
PyObject *handler;
+#ifndef AEInstallEventHandler
+ PyMac_PRECHECK(AEInstallEventHandler);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O",
PyMac_GetOSType, &theAEEventClass,
PyMac_GetOSType, &theAEEventID,
OSErr _err;
AEEventClass theAEEventClass;
AEEventID theAEEventID;
+#ifndef AERemoveEventHandler
+ PyMac_PRECHECK(AERemoveEventHandler);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetOSType, &theAEEventClass,
PyMac_GetOSType, &theAEEventID))
AEEventID theAEEventID;
AEEventHandlerUPP handler__proc__ = upp_GenericEventHandler;
PyObject *handler;
+#ifndef AEGetEventHandler
+ PyMac_PRECHECK(AEGetEventHandler);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetOSType, &theAEEventClass,
PyMac_GetOSType, &theAEEventID))
PyObject *_res = NULL;
OSErr _err;
AEKeyword functionClass;
+#ifndef AEInstallSpecialHandler
+ PyMac_PRECHECK(AEInstallSpecialHandler);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetOSType, &functionClass))
return NULL;
PyObject *_res = NULL;
OSErr _err;
AEKeyword functionClass;
+#ifndef AERemoveSpecialHandler
+ PyMac_PRECHECK(AERemoveSpecialHandler);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetOSType, &functionClass))
return NULL;
OSErr _err;
AEKeyword keyWord;
long result;
+#ifndef AEManagerInfo
+ PyMac_PRECHECK(AEManagerInfo);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetOSType, &keyWord))
return NULL;
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef AEObjectInit
+ PyMac_PRECHECK(AEObjectInit);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = AEObjectInit();
PyObject *_res = NULL;
OSErr _err;
AEDesc theToken;
+#ifndef AEDisposeToken
+ PyMac_PRECHECK(AEDisposeToken);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = AEDisposeToken(&theToken);
DescType keyForm;
AEDesc keyData;
AEDesc token;
+#ifndef AECallObjectAccessor
+ PyMac_PRECHECK(AECallObjectAccessor);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&O&O&",
PyMac_GetOSType, &desiredClass,
AEDesc_Convert, &containerToken,
PyObject *_res = NULL;
OSStatus _rv;
Boolean inDisposeNow;
+#ifndef SetThemeDrawingState
+ PyMac_PRECHECK(SetThemeDrawingState);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&inDisposeNow))
return NULL;
{
PyObject *_res = NULL;
OSStatus _rv;
+#ifndef DisposeThemeDrawingState
+ PyMac_PRECHECK(DisposeThemeDrawingState);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = DisposeThemeDrawingState(_self->ob_itself);
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef RegisterAppearanceClient
+ PyMac_PRECHECK(RegisterAppearanceClient);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = RegisterAppearanceClient();
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef UnregisterAppearanceClient
+ PyMac_PRECHECK(UnregisterAppearanceClient);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = UnregisterAppearanceClient();
ThemeBrush inBrush;
SInt16 inDepth;
Boolean inIsColorDevice;
+#ifndef SetThemePen
+ PyMac_PRECHECK(SetThemePen);
+#endif
if (!PyArg_ParseTuple(_args, "hhb",
&inBrush,
&inDepth,
ThemeBrush inBrush;
SInt16 inDepth;
Boolean inIsColorDevice;
+#ifndef SetThemeBackground
+ PyMac_PRECHECK(SetThemeBackground);
+#endif
if (!PyArg_ParseTuple(_args, "hhb",
&inBrush,
&inDepth,
ThemeTextColor inColor;
SInt16 inDepth;
Boolean inIsColorDevice;
+#ifndef SetThemeTextColor
+ PyMac_PRECHECK(SetThemeTextColor);
+#endif
if (!PyArg_ParseTuple(_args, "hhb",
&inColor,
&inDepth,
WindowPtr inWindow;
ThemeBrush inBrush;
Boolean inUpdate;
+#ifndef SetThemeWindowBackground
+ PyMac_PRECHECK(SetThemeWindowBackground);
+#endif
if (!PyArg_ParseTuple(_args, "O&hb",
WinObj_Convert, &inWindow,
&inBrush,
OSStatus _err;
Rect inRect;
ThemeDrawState inState;
+#ifndef DrawThemeWindowHeader
+ PyMac_PRECHECK(DrawThemeWindowHeader);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetRect, &inRect,
&inState))
OSStatus _err;
Rect inRect;
ThemeDrawState inState;
+#ifndef DrawThemeWindowListViewHeader
+ PyMac_PRECHECK(DrawThemeWindowListViewHeader);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetRect, &inRect,
&inState))
OSStatus _err;
Rect inRect;
ThemeDrawState inState;
+#ifndef DrawThemePlacard
+ PyMac_PRECHECK(DrawThemePlacard);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetRect, &inRect,
&inState))
OSStatus _err;
Rect inRect;
ThemeDrawState inState;
+#ifndef DrawThemeEditTextFrame
+ PyMac_PRECHECK(DrawThemeEditTextFrame);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetRect, &inRect,
&inState))
OSStatus _err;
Rect inRect;
ThemeDrawState inState;
+#ifndef DrawThemeListBoxFrame
+ PyMac_PRECHECK(DrawThemeListBoxFrame);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetRect, &inRect,
&inState))
OSStatus _err;
Rect inRect;
Boolean inHasFocus;
+#ifndef DrawThemeFocusRect
+ PyMac_PRECHECK(DrawThemeFocusRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&b",
PyMac_GetRect, &inRect,
&inHasFocus))
OSStatus _err;
Rect inRect;
ThemeDrawState inState;
+#ifndef DrawThemePrimaryGroup
+ PyMac_PRECHECK(DrawThemePrimaryGroup);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetRect, &inRect,
&inState))
OSStatus _err;
Rect inRect;
ThemeDrawState inState;
+#ifndef DrawThemeSecondaryGroup
+ PyMac_PRECHECK(DrawThemeSecondaryGroup);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetRect, &inRect,
&inState))
OSStatus _err;
Rect inRect;
ThemeDrawState inState;
+#ifndef DrawThemeSeparator
+ PyMac_PRECHECK(DrawThemeSeparator);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetRect, &inRect,
&inState))
OSStatus _err;
Rect inRect;
ThemeDrawState inState;
+#ifndef DrawThemeModelessDialogFrame
+ PyMac_PRECHECK(DrawThemeModelessDialogFrame);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetRect, &inRect,
&inState))
Rect inRect;
ThemeDrawState inState;
Boolean inFillCenter;
+#ifndef DrawThemeGenericWell
+ PyMac_PRECHECK(DrawThemeGenericWell);
+#endif
if (!PyArg_ParseTuple(_args, "O&lb",
PyMac_GetRect, &inRect,
&inState,
PyObject *_res = NULL;
OSStatus _err;
Boolean inHasFocus;
+#ifndef DrawThemeFocusRegion
+ PyMac_PRECHECK(DrawThemeFocusRegion);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&inHasFocus))
return NULL;
Boolean _rv;
SInt16 inDepth;
Boolean inIsColorDevice;
+#ifndef IsThemeInColor
+ PyMac_PRECHECK(IsThemeInColor);
+#endif
if (!PyArg_ParseTuple(_args, "hb",
&inDepth,
&inIsColorDevice))
PyObject *_res = NULL;
OSStatus _err;
CTabHandle outColors;
+#ifndef GetThemeAccentColors
+ PyMac_PRECHECK(GetThemeAccentColors);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetThemeAccentColors(&outColors);
Rect inBounds;
ThemeMenuBarState inState;
UInt32 inAttributes;
+#ifndef DrawThemeMenuBarBackground
+ PyMac_PRECHECK(DrawThemeMenuBarBackground);
+#endif
if (!PyArg_ParseTuple(_args, "O&Hl",
PyMac_GetRect, &inBounds,
&inState,
PyObject *_res = NULL;
OSStatus _err;
SInt16 outHeight;
+#ifndef GetThemeMenuBarHeight
+ PyMac_PRECHECK(GetThemeMenuBarHeight);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetThemeMenuBarHeight(&outHeight);
OSStatus _err;
Rect inMenuRect;
ThemeMenuType inMenuType;
+#ifndef DrawThemeMenuBackground
+ PyMac_PRECHECK(DrawThemeMenuBackground);
+#endif
if (!PyArg_ParseTuple(_args, "O&H",
PyMac_GetRect, &inMenuRect,
&inMenuType))
OSStatus _err;
Rect inMenuRect;
ThemeMenuType menuType;
+#ifndef GetThemeMenuBackgroundRegion
+ PyMac_PRECHECK(GetThemeMenuBackgroundRegion);
+#endif
if (!PyArg_ParseTuple(_args, "O&H",
PyMac_GetRect, &inMenuRect,
&menuType))
PyObject *_res = NULL;
OSStatus _err;
Rect inItemRect;
+#ifndef DrawThemeMenuSeparator
+ PyMac_PRECHECK(DrawThemeMenuSeparator);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &inItemRect))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
SInt16 outHeight;
+#ifndef GetThemeMenuSeparatorHeight
+ PyMac_PRECHECK(GetThemeMenuSeparatorHeight);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetThemeMenuSeparatorHeight(&outHeight);
ThemeMenuItemType inItemType;
SInt16 outHeight;
SInt16 outWidth;
+#ifndef GetThemeMenuItemExtra
+ PyMac_PRECHECK(GetThemeMenuItemExtra);
+#endif
if (!PyArg_ParseTuple(_args, "H",
&inItemType))
return NULL;
OSStatus _err;
SInt16 outWidth;
Boolean inIsSquished;
+#ifndef GetThemeMenuTitleExtra
+ PyMac_PRECHECK(GetThemeMenuTitleExtra);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&inIsSquished))
return NULL;
OSStatus _err;
Rect inRect;
ThemeDrawState inState;
+#ifndef DrawThemeTabPane
+ PyMac_PRECHECK(DrawThemeTabPane);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetRect, &inRect,
&inState))
Rect inRect;
ThemeTabStyle inStyle;
ThemeTabDirection inDirection;
+#ifndef GetThemeTabRegion
+ PyMac_PRECHECK(GetThemeTabRegion);
+#endif
if (!PyArg_ParseTuple(_args, "O&HH",
PyMac_GetRect, &inRect,
&inStyle,
PyObject *_res = NULL;
OSStatus _err;
ThemeCursor inCursor;
+#ifndef SetThemeCursor
+ PyMac_PRECHECK(SetThemeCursor);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&inCursor))
return NULL;
OSStatus _err;
ThemeCursor inCursor;
UInt32 inAnimationStep;
+#ifndef SetAnimatedThemeCursor
+ PyMac_PRECHECK(SetAnimatedThemeCursor);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&inCursor,
&inAnimationStep))
PyObject *_res = NULL;
OSStatus _err;
ThemeScrollBarThumbStyle outStyle;
+#ifndef GetThemeScrollBarThumbStyle
+ PyMac_PRECHECK(GetThemeScrollBarThumbStyle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetThemeScrollBarThumbStyle(&outStyle);
PyObject *_res = NULL;
OSStatus _err;
ThemeScrollBarArrowStyle outStyle;
+#ifndef GetThemeScrollBarArrowStyle
+ PyMac_PRECHECK(GetThemeScrollBarArrowStyle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetThemeScrollBarArrowStyle(&outStyle);
PyObject *_res = NULL;
OSStatus _err;
ThemeCheckBoxStyle outStyle;
+#ifndef GetThemeCheckBoxStyle
+ PyMac_PRECHECK(GetThemeCheckBoxStyle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetThemeCheckBoxStyle(&outStyle);
OSStatus _err;
ThemeFontID inFontID;
ScriptCode inScript;
+#ifndef UseThemeFont
+ PyMac_PRECHECK(UseThemeFont);
+#endif
if (!PyArg_ParseTuple(_args, "Hh",
&inFontID,
&inScript))
Boolean inWrapToWidth;
Rect inBoundingBox;
SInt16 inJust;
+#ifndef DrawThemeTextBox
+ PyMac_PRECHECK(DrawThemeTextBox);
+#endif
if (!PyArg_ParseTuple(_args, "O&HlbO&h",
CFStringRefObj_Convert, &inString,
&inFontID,
SInt16 inPixelWidthLimit;
TruncCode inTruncWhere;
Boolean outTruncated;
+#ifndef TruncateThemeText
+ PyMac_PRECHECK(TruncateThemeText);
+#endif
if (!PyArg_ParseTuple(_args, "O&Hlhh",
CFMutableStringRefObj_Convert, &inString,
&inFontID,
Boolean inWrapToWidth;
Point ioBounds;
SInt16 outBaseline;
+#ifndef GetThemeTextDimensions
+ PyMac_PRECHECK(GetThemeTextDimensions);
+#endif
if (!PyArg_ParseTuple(_args, "O&HlbO&",
CFStringRefObj_Convert, &inString,
&inFontID,
ThemeFontID inFontID;
ThemeDrawState inState;
Rect outOutset;
+#ifndef GetThemeTextShadowOutset
+ PyMac_PRECHECK(GetThemeTextShadowOutset);
+#endif
if (!PyArg_ParseTuple(_args, "Hl",
&inFontID,
&inState))
ThemeTrackPressState pressState;
Boolean isHoriz;
Rect trackBounds;
+#ifndef DrawThemeScrollBarArrows
+ PyMac_PRECHECK(DrawThemeScrollBarArrows);
+#endif
if (!PyArg_ParseTuple(_args, "O&bbb",
PyMac_GetRect, &bounds,
&enableState,
ThemeTrackPressState pressState;
Boolean isHoriz;
Rect trackBounds;
+#ifndef GetThemeScrollBarTrackRect
+ PyMac_PRECHECK(GetThemeScrollBarTrackRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&bbb",
PyMac_GetRect, &bounds,
&enableState,
Point ptHit;
Rect trackBounds;
ControlPartCode partcode;
+#ifndef HitTestThemeScrollBarArrows
+ PyMac_PRECHECK(HitTestThemeScrollBarArrows);
+#endif
if (!PyArg_ParseTuple(_args, "O&bbbO&",
PyMac_GetRect, &scrollBarBounds,
&enableState,
Rect inContRect;
ThemeDrawState state;
ThemeWindowAttributes attributes;
+#ifndef DrawThemeScrollBarDelimiters
+ PyMac_PRECHECK(DrawThemeScrollBarDelimiters);
+#endif
if (!PyArg_ParseTuple(_args, "HO&ll",
&flavor,
PyMac_GetRect, &inContRect,
ThemeButtonDrawInfo inNewInfo;
ThemeButtonDrawInfo inPrevInfo;
UInt32 inUserData;
+#ifndef DrawThemeButton
+ PyMac_PRECHECK(DrawThemeButton);
+#endif
if (!PyArg_ParseTuple(_args, "O&HO&O&l",
PyMac_GetRect, &inBounds,
&inKind,
Rect inBounds;
UInt16 inKind;
ThemeButtonDrawInfo inNewInfo;
+#ifndef GetThemeButtonRegion
+ PyMac_PRECHECK(GetThemeButtonRegion);
+#endif
if (!PyArg_ParseTuple(_args, "O&HO&",
PyMac_GetRect, &inBounds,
&inKind,
UInt16 inKind;
ThemeButtonDrawInfo inDrawInfo;
Rect outBounds;
+#ifndef GetThemeButtonContentBounds
+ PyMac_PRECHECK(GetThemeButtonContentBounds);
+#endif
if (!PyArg_ParseTuple(_args, "O&HO&",
PyMac_GetRect, &inBounds,
&inKind,
UInt16 inKind;
ThemeButtonDrawInfo inDrawInfo;
Rect outBounds;
+#ifndef GetThemeButtonBackgroundBounds
+ PyMac_PRECHECK(GetThemeButtonBackgroundBounds);
+#endif
if (!PyArg_ParseTuple(_args, "O&HO&",
PyMac_GetRect, &inBounds,
&inKind,
PyObject *_res = NULL;
OSStatus _err;
ThemeSoundKind kind;
+#ifndef PlayThemeSound
+ PyMac_PRECHECK(PlayThemeSound);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetOSType, &kind))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
ThemeDragSoundKind kind;
+#ifndef BeginThemeDragSound
+ PyMac_PRECHECK(BeginThemeDragSound);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetOSType, &kind))
return NULL;
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef EndThemeDragSound
+ PyMac_PRECHECK(EndThemeDragSound);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = EndThemeDragSound();
OSStatus _err;
Rect bounds;
ThemeDrawState state;
+#ifndef DrawThemeTickMark
+ PyMac_PRECHECK(DrawThemeTickMark);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetRect, &bounds,
&state))
UInt32 index;
ThemeDrawState state;
UInt32 eraseData;
+#ifndef DrawThemeChasingArrows
+ PyMac_PRECHECK(DrawThemeChasingArrows);
+#endif
if (!PyArg_ParseTuple(_args, "O&lll",
PyMac_GetRect, &bounds,
&index,
ThemePopupArrowSize size;
ThemeDrawState state;
UInt32 eraseData;
+#ifndef DrawThemePopupArrow
+ PyMac_PRECHECK(DrawThemePopupArrow);
+#endif
if (!PyArg_ParseTuple(_args, "O&HHll",
PyMac_GetRect, &bounds,
&orientation,
ThemeGrowDirection growDirection;
Boolean isSmall;
ThemeDrawState state;
+#ifndef DrawThemeStandaloneGrowBox
+ PyMac_PRECHECK(DrawThemeStandaloneGrowBox);
+#endif
if (!PyArg_ParseTuple(_args, "O&Hbl",
PyMac_GetPoint, &origin,
&growDirection,
ThemeGrowDirection growDirection;
Boolean isSmall;
ThemeDrawState state;
+#ifndef DrawThemeStandaloneNoGrowBox
+ PyMac_PRECHECK(DrawThemeStandaloneNoGrowBox);
+#endif
if (!PyArg_ParseTuple(_args, "O&Hbl",
PyMac_GetPoint, &origin,
&growDirection,
ThemeGrowDirection growDirection;
Boolean isSmall;
Rect bounds;
+#ifndef GetThemeStandaloneGrowBoxBounds
+ PyMac_PRECHECK(GetThemeStandaloneGrowBoxBounds);
+#endif
if (!PyArg_ParseTuple(_args, "O&Hb",
PyMac_GetPoint, &origin,
&growDirection,
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef NormalizeThemeDrawingState
+ PyMac_PRECHECK(NormalizeThemeDrawingState);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = NormalizeThemeDrawingState();
PyObject *_res = NULL;
OSStatus _err;
ThemeDrawingState outState;
+#ifndef GetThemeDrawingState
+ PyMac_PRECHECK(GetThemeDrawingState);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetThemeDrawingState(&outState);
ThemeDrawState inState;
SInt16 inDepth;
Boolean inColorDev;
+#ifndef ApplyThemeBackground
+ PyMac_PRECHECK(ApplyThemeBackground);
+#endif
if (!PyArg_ParseTuple(_args, "lO&lhb",
&inKind,
PyMac_GetRect, &bounds,
Boolean isActive;
SInt16 depth;
Boolean isColorDev;
+#ifndef SetThemeTextColorForWindow
+ PyMac_PRECHECK(SetThemeTextColorForWindow);
+#endif
if (!PyArg_ParseTuple(_args, "O&bhb",
WinObj_Convert, &window,
&isActive,
PyObject *_res = NULL;
Boolean _rv;
OSType fileType;
+#ifndef IsValidAppearanceFileType
+ PyMac_PRECHECK(IsValidAppearanceFileType);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetOSType, &fileType))
return NULL;
SInt16 inDepth;
Boolean inColorDev;
RGBColor outColor;
+#ifndef GetThemeBrushAsColor
+ PyMac_PRECHECK(GetThemeBrushAsColor);
+#endif
if (!PyArg_ParseTuple(_args, "hhb",
&inBrush,
&inDepth,
SInt16 inDepth;
Boolean inColorDev;
RGBColor outColor;
+#ifndef GetThemeTextColor
+ PyMac_PRECHECK(GetThemeTextColor);
+#endif
if (!PyArg_ParseTuple(_args, "hhb",
&inColor,
&inDepth,
OSStatus _err;
ThemeMetric inMetric;
SInt32 outMetric;
+#ifndef GetThemeMetric
+ PyMac_PRECHECK(GetThemeMetric);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&inMetric))
return NULL;
module.addobject(object)
ThemeDrawingState = OpaqueByValueType("ThemeDrawingState", "ThemeDrawingStateObj")
-Method = MethodGenerator
+Method = WeakLinkMethodGenerator
# Create the generator classes used to populate the lists
-Function = OSErrFunctionGenerator
-##Method = OSErrMethodGenerator
+Function = OSErrWeakLinkFunctionGenerator
+##Method = OSErrWeakLinkMethodGenerator
# Create and populate the lists
functions = []
"CFStringCreateMutableWithExternalCharactersNoCopy", # Not a clue...
"CFStringSetExternalCharactersNoCopy",
"CFStringGetCharacterAtIndex", # No format for single unichars yet.
+ "kCFStringEncodingInvalidId", # incompatible constant declaration
]
def makegreylist(self):
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef CloseComponent
+ PyMac_PRECHECK(CloseComponent);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = CloseComponent(_self->ob_itself);
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef GetComponentInstanceError
+ PyMac_PRECHECK(GetComponentInstanceError);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetComponentInstanceError(_self->ob_itself);
{
PyObject *_res = NULL;
OSErr theError;
+#ifndef SetComponentInstanceError
+ PyMac_PRECHECK(SetComponentInstanceError);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&theError))
return NULL;
{
PyObject *_res = NULL;
Handle _rv;
+#ifndef GetComponentInstanceStorage
+ PyMac_PRECHECK(GetComponentInstanceStorage);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetComponentInstanceStorage(_self->ob_itself);
{
PyObject *_res = NULL;
Handle theStorage;
+#ifndef SetComponentInstanceStorage
+ PyMac_PRECHECK(SetComponentInstanceStorage);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &theStorage))
return NULL;
{
PyObject *_res = NULL;
long _rv;
+#ifndef GetComponentInstanceA5
+ PyMac_PRECHECK(GetComponentInstanceA5);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetComponentInstanceA5(_self->ob_itself);
{
PyObject *_res = NULL;
long theA5;
+#ifndef SetComponentInstanceA5
+ PyMac_PRECHECK(SetComponentInstanceA5);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&theA5))
return NULL;
PyObject *_res = NULL;
long _rv;
short ftnNumber;
+#ifndef ComponentFunctionImplemented
+ PyMac_PRECHECK(ComponentFunctionImplemented);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&ftnNumber))
return NULL;
{
PyObject *_res = NULL;
long _rv;
+#ifndef GetComponentVersion
+ PyMac_PRECHECK(GetComponentVersion);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetComponentVersion(_self->ob_itself);
PyObject *_res = NULL;
long _rv;
ComponentInstance target;
+#ifndef ComponentSetTarget
+ PyMac_PRECHECK(ComponentSetTarget);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CmpInstObj_Convert, &target))
return NULL;
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef UnregisterComponent
+ PyMac_PRECHECK(UnregisterComponent);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = UnregisterComponent(_self->ob_itself);
Handle componentName;
Handle componentInfo;
Handle componentIcon;
+#ifndef GetComponentInfo
+ PyMac_PRECHECK(GetComponentInfo);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
ResObj_Convert, &componentName,
ResObj_Convert, &componentInfo,
{
PyObject *_res = NULL;
ComponentInstance _rv;
+#ifndef OpenComponent
+ PyMac_PRECHECK(OpenComponent);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = OpenComponent(_self->ob_itself);
{
PyObject *_res = NULL;
Component _rv;
+#ifndef ResolveComponentAlias
+ PyMac_PRECHECK(ResolveComponentAlias);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = ResolveComponentAlias(_self->ob_itself);
Str255 theString;
short strListID;
short index;
+#ifndef GetComponentPublicIndString
+ PyMac_PRECHECK(GetComponentPublicIndString);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
PyMac_GetStr255, theString,
&strListID,
{
PyObject *_res = NULL;
long _rv;
+#ifndef GetComponentRefcon
+ PyMac_PRECHECK(GetComponentRefcon);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetComponentRefcon(_self->ob_itself);
{
PyObject *_res = NULL;
long theRefcon;
+#ifndef SetComponentRefcon
+ PyMac_PRECHECK(SetComponentRefcon);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&theRefcon))
return NULL;
{
PyObject *_res = NULL;
short _rv;
+#ifndef OpenComponentResFile
+ PyMac_PRECHECK(OpenComponentResFile);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = OpenComponentResFile(_self->ob_itself);
OSType resType;
short resID;
Handle theResource;
+#ifndef GetComponentResource
+ PyMac_PRECHECK(GetComponentResource);
+#endif
if (!PyArg_ParseTuple(_args, "O&h",
PyMac_GetOSType, &resType,
&resID))
Str255 theString;
short strListID;
short index;
+#ifndef GetComponentIndString
+ PyMac_PRECHECK(GetComponentIndString);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
PyMac_GetStr255, theString,
&strListID,
{
PyObject *_res = NULL;
long _rv;
+#ifndef CountComponentInstances
+ PyMac_PRECHECK(CountComponentInstances);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CountComponentInstances(_self->ob_itself);
PyObject *_res = NULL;
OSErr _err;
short flags;
+#ifndef SetDefaultComponent
+ PyMac_PRECHECK(SetDefaultComponent);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&flags))
return NULL;
PyObject *_res = NULL;
Component _rv;
Component capturingComponent;
+#ifndef CaptureComponent
+ PyMac_PRECHECK(CaptureComponent);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CmpObj_Convert, &capturingComponent))
return NULL;
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef UncaptureComponent
+ PyMac_PRECHECK(UncaptureComponent);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = UncaptureComponent(_self->ob_itself);
PyObject *_res = NULL;
OSErr _err;
Handle iconSuite;
+#ifndef GetComponentIconSuite
+ PyMac_PRECHECK(GetComponentIconSuite);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetComponentIconSuite(_self->ob_itself,
Component _rv;
ComponentResourceHandle cr;
short global;
+#ifndef RegisterComponentResource
+ PyMac_PRECHECK(RegisterComponentResource);
+#endif
if (!PyArg_ParseTuple(_args, "O&h",
ResObj_Convert, &cr,
&global))
Component _rv;
Component aComponent;
ComponentDescription looking;
+#ifndef FindNextComponent
+ PyMac_PRECHECK(FindNextComponent);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
CmpObj_Convert, &aComponent,
CmpDesc_Convert, &looking))
PyObject *_res = NULL;
long _rv;
ComponentDescription looking;
+#ifndef CountComponents
+ PyMac_PRECHECK(CountComponents);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CmpDesc_Convert, &looking))
return NULL;
{
PyObject *_res = NULL;
long _rv;
+#ifndef GetComponentListModSeed
+ PyMac_PRECHECK(GetComponentListModSeed);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetComponentListModSeed();
PyObject *_res = NULL;
OSErr _err;
short refnum;
+#ifndef CloseComponentResFile
+ PyMac_PRECHECK(CloseComponentResFile);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&refnum))
return NULL;
ComponentInstance _rv;
OSType componentType;
OSType componentSubType;
+#ifndef OpenDefaultComponent
+ PyMac_PRECHECK(OpenDefaultComponent);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetOSType, &componentType,
PyMac_GetOSType, &componentSubType))
long _rv;
short resRefNum;
short global;
+#ifndef RegisterComponentResourceFile
+ PyMac_PRECHECK(RegisterComponentResourceFile);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&resRefNum,
&global))
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef DisposeDrag
+ PyMac_PRECHECK(DisposeDrag);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = DisposeDrag(_self->ob_itself);
long dataPtr__len__;
int dataPtr__in_len__;
FlavorFlags theFlags;
+#ifndef AddDragItemFlavor
+ PyMac_PRECHECK(AddDragItemFlavor);
+#endif
if (!PyArg_ParseTuple(_args, "lO&z#l",
&theItemRef,
PyMac_GetOSType, &theType,
long dataPtr__len__;
int dataPtr__in_len__;
UInt32 dataOffset;
+#ifndef SetDragItemFlavorData
+ PyMac_PRECHECK(SetDragItemFlavorData);
+#endif
if (!PyArg_ParseTuple(_args, "lO&z#l",
&theItemRef,
PyMac_GetOSType, &theType,
RgnHandle imageRgn;
Point imageOffsetPt;
DragImageFlags theImageFlags;
+#ifndef SetDragImage
+ PyMac_PRECHECK(SetDragImage);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&l",
ResObj_Convert, &imagePixMap,
ResObj_Convert, &imageRgn,
OSErr _err;
DragBehaviors inBehaviorsToSet;
DragBehaviors inBehaviorsToClear;
+#ifndef ChangeDragBehaviors
+ PyMac_PRECHECK(ChangeDragBehaviors);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&inBehaviorsToSet,
&inBehaviorsToClear))
OSErr _err;
EventRecord theEvent;
RgnHandle theRegion;
+#ifndef TrackDrag
+ PyMac_PRECHECK(TrackDrag);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetEventRecord, &theEvent,
ResObj_Convert, &theRegion))
PyObject *_res = NULL;
OSErr _err;
UInt16 numItems;
+#ifndef CountDragItems
+ PyMac_PRECHECK(CountDragItems);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = CountDragItems(_self->ob_itself,
OSErr _err;
UInt16 index;
ItemReference theItemRef;
+#ifndef GetDragItemReferenceNumber
+ PyMac_PRECHECK(GetDragItemReferenceNumber);
+#endif
if (!PyArg_ParseTuple(_args, "H",
&index))
return NULL;
OSErr _err;
ItemReference theItemRef;
UInt16 numFlavors;
+#ifndef CountDragItemFlavors
+ PyMac_PRECHECK(CountDragItemFlavors);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&theItemRef))
return NULL;
ItemReference theItemRef;
UInt16 index;
FlavorType theType;
+#ifndef GetFlavorType
+ PyMac_PRECHECK(GetFlavorType);
+#endif
if (!PyArg_ParseTuple(_args, "lH",
&theItemRef,
&index))
ItemReference theItemRef;
FlavorType theType;
FlavorFlags theFlags;
+#ifndef GetFlavorFlags
+ PyMac_PRECHECK(GetFlavorFlags);
+#endif
if (!PyArg_ParseTuple(_args, "lO&",
&theItemRef,
PyMac_GetOSType, &theType))
ItemReference theItemRef;
FlavorType theType;
Size dataSize;
+#ifndef GetFlavorDataSize
+ PyMac_PRECHECK(GetFlavorDataSize);
+#endif
if (!PyArg_ParseTuple(_args, "lO&",
&theItemRef,
PyMac_GetOSType, &theType))
long dataPtr__len__;
int dataPtr__in_len__;
UInt32 dataOffset;
+#ifndef GetFlavorData
+ PyMac_PRECHECK(GetFlavorData);
+#endif
if (!PyArg_ParseTuple(_args, "lO&il",
&theItemRef,
PyMac_GetOSType, &theType,
OSErr _err;
ItemReference theItemRef;
Rect itemBounds;
+#ifndef GetDragItemBounds
+ PyMac_PRECHECK(GetDragItemBounds);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&theItemRef))
return NULL;
OSErr _err;
ItemReference theItemRef;
Rect itemBounds;
+#ifndef SetDragItemBounds
+ PyMac_PRECHECK(SetDragItemBounds);
+#endif
if (!PyArg_ParseTuple(_args, "lO&",
&theItemRef,
PyMac_GetRect, &itemBounds))
PyObject *_res = NULL;
OSErr _err;
AEDesc dropLocation;
+#ifndef GetDropLocation
+ PyMac_PRECHECK(GetDropLocation);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetDropLocation(_self->ob_itself,
PyObject *_res = NULL;
OSErr _err;
AEDesc dropLocation;
+#ifndef SetDropLocation
+ PyMac_PRECHECK(SetDropLocation);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
AEDesc_Convert, &dropLocation))
return NULL;
PyObject *_res = NULL;
OSErr _err;
DragAttributes flags;
+#ifndef GetDragAttributes
+ PyMac_PRECHECK(GetDragAttributes);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetDragAttributes(_self->ob_itself,
OSErr _err;
Point mouse;
Point globalPinnedMouse;
+#ifndef GetDragMouse
+ PyMac_PRECHECK(GetDragMouse);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetDragMouse(_self->ob_itself,
PyObject *_res = NULL;
OSErr _err;
Point globalPinnedMouse;
+#ifndef SetDragMouse
+ PyMac_PRECHECK(SetDragMouse);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetPoint, &globalPinnedMouse))
return NULL;
PyObject *_res = NULL;
OSErr _err;
Point globalInitialMouse;
+#ifndef GetDragOrigin
+ PyMac_PRECHECK(GetDragOrigin);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetDragOrigin(_self->ob_itself,
SInt16 modifiers;
SInt16 mouseDownModifiers;
SInt16 mouseUpModifiers;
+#ifndef GetDragModifiers
+ PyMac_PRECHECK(GetDragModifiers);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetDragModifiers(_self->ob_itself,
OSErr _err;
RgnHandle hiliteFrame;
Boolean inside;
+#ifndef ShowDragHilite
+ PyMac_PRECHECK(ShowDragHilite);
+#endif
if (!PyArg_ParseTuple(_args, "O&b",
ResObj_Convert, &hiliteFrame,
&inside))
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef HideDragHilite
+ PyMac_PRECHECK(HideDragHilite);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = HideDragHilite(_self->ob_itself);
OSErr _err;
SInt16 dH;
SInt16 dV;
+#ifndef DragPreScroll
+ PyMac_PRECHECK(DragPreScroll);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&dH,
&dV))
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef DragPostScroll
+ PyMac_PRECHECK(DragPostScroll);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = DragPostScroll(_self->ob_itself);
PyObject *_res = NULL;
OSErr _err;
RgnHandle updateRgn;
+#ifndef UpdateDragHilite
+ PyMac_PRECHECK(UpdateDragHilite);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &updateRgn))
return NULL;
PyObject *_res = NULL;
OSErr _err;
DragRef theDrag;
+#ifndef NewDrag
+ PyMac_PRECHECK(NewDrag);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = NewDrag(&theDrag);
OSErr _err;
WindowPtr window;
RGBColor color;
+#ifndef GetDragHiliteColor
+ PyMac_PRECHECK(GetDragHiliteColor);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
WinObj_Convert, &window))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
Point initialMouse;
+#ifndef WaitMouseMoved
+ PyMac_PRECHECK(WaitMouseMoved);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetPoint, &initialMouse))
return NULL;
Rect toRect;
SInt16 zoomSteps;
ZoomAcceleration acceleration;
+#ifndef ZoomRects
+ PyMac_PRECHECK(ZoomRects);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&hh",
PyMac_GetRect, &fromRect,
PyMac_GetRect, &toRect,
Point zoomDistance;
SInt16 zoomSteps;
ZoomAcceleration acceleration;
+#ifndef ZoomRegion
+ PyMac_PRECHECK(ZoomRegion);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&hh",
ResObj_Convert, ®ion,
PyMac_GetPoint, &zoomDistance,
{
PyObject *_res = NULL;
Point mouseLoc;
+#ifndef GetMouse
+ PyMac_PRECHECK(GetMouse);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetMouse(&mouseLoc);
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef Button
+ PyMac_PRECHECK(Button);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = Button();
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef StillDown
+ PyMac_PRECHECK(StillDown);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = StillDown();
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef WaitMouseUp
+ PyMac_PRECHECK(WaitMouseUp);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = WaitMouseUp();
{
PyObject *_res = NULL;
UInt32 _rv;
+#ifndef GetCaretTime
+ PyMac_PRECHECK(GetCaretTime);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetCaretTime();
{
PyObject *_res = NULL;
KeyMap theKeys__out__;
+#ifndef GetKeys
+ PyMac_PRECHECK(GetKeys);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetKeys(theKeys__out__);
{
PyObject *_res = NULL;
UInt32 _rv;
+#ifndef GetDblTime
+ PyMac_PRECHECK(GetDblTime);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetDblTime();
{
PyObject *_res = NULL;
EventMask value;
+#ifndef SetEventMask
+ PyMac_PRECHECK(SetEventMask);
+#endif
if (!PyArg_ParseTuple(_args, "H",
&value))
return NULL;
Boolean _rv;
EventMask eventMask;
EventRecord theEvent;
+#ifndef GetNextEvent
+ PyMac_PRECHECK(GetNextEvent);
+#endif
if (!PyArg_ParseTuple(_args, "H",
&eventMask))
return NULL;
Boolean _rv;
EventMask eventMask;
EventRecord theEvent;
+#ifndef EventAvail
+ PyMac_PRECHECK(EventAvail);
+#endif
if (!PyArg_ParseTuple(_args, "H",
&eventMask))
return NULL;
OSErr _err;
EventKind eventNum;
UInt32 eventMsg;
+#ifndef PostEvent
+ PyMac_PRECHECK(PostEvent);
+#endif
if (!PyArg_ParseTuple(_args, "Hl",
&eventNum,
&eventMsg))
Boolean _rv;
EventMask mask;
EventRecord theEvent;
+#ifndef OSEventAvail
+ PyMac_PRECHECK(OSEventAvail);
+#endif
if (!PyArg_ParseTuple(_args, "H",
&mask))
return NULL;
Boolean _rv;
EventMask mask;
EventRecord theEvent;
+#ifndef GetOSEvent
+ PyMac_PRECHECK(GetOSEvent);
+#endif
if (!PyArg_ParseTuple(_args, "H",
&mask))
return NULL;
PyObject *_res = NULL;
EventMask whichMask;
EventMask stopMask;
+#ifndef FlushEvents
+ PyMac_PRECHECK(FlushEvents);
+#endif
if (!PyArg_ParseTuple(_args, "HH",
&whichMask,
&stopMask))
PyObject *_res = NULL;
EventRecord theEvent;
WindowPtr theWindow;
+#ifndef SystemClick
+ PyMac_PRECHECK(SystemClick);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetEventRecord, &theEvent,
WinObj_Convert, &theWindow))
static PyObject *Evt_SystemTask(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef SystemTask
+ PyMac_PRECHECK(SystemTask);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
SystemTask();
PyObject *_res = NULL;
Boolean _rv;
EventRecord theEvent;
+#ifndef SystemEvent
+ PyMac_PRECHECK(SystemEvent);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetEventRecord, &theEvent))
return NULL;
{
PyObject *_res = NULL;
Point globalMouse;
+#ifndef GetGlobalMouse
+ PyMac_PRECHECK(GetGlobalMouse);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetGlobalMouse(&globalMouse);
{
PyObject *_res = NULL;
UInt32 _rv;
+#ifndef GetCurrentKeyModifiers
+ PyMac_PRECHECK(GetCurrentKeyModifiers);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetCurrentKeyModifiers();
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef CheckEventQueueForUserCancel
+ PyMac_PRECHECK(CheckEventQueueForUserCancel);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CheckEventQueueForUserCancel();
{
PyObject *_res = NULL;
short code;
+#ifndef KeyScript
+ PyMac_PRECHECK(KeyScript);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&code))
return NULL;
Boolean _rv;
EventRecord event;
short test;
+#ifndef IsCmdChar
+ PyMac_PRECHECK(IsCmdChar);
+#endif
if (!PyArg_ParseTuple(_args, "O&h",
PyMac_GetEventRecord, &event,
&test))
{
PyObject *_res = NULL;
SInt16 _rv;
+#ifndef LMGetKeyThresh
+ PyMac_PRECHECK(LMGetKeyThresh);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = LMGetKeyThresh();
{
PyObject *_res = NULL;
SInt16 value;
+#ifndef LMSetKeyThresh
+ PyMac_PRECHECK(LMSetKeyThresh);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&value))
return NULL;
{
PyObject *_res = NULL;
SInt16 _rv;
+#ifndef LMGetKeyRepThresh
+ PyMac_PRECHECK(LMGetKeyRepThresh);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = LMGetKeyRepThresh();
{
PyObject *_res = NULL;
SInt16 value;
+#ifndef LMSetKeyRepThresh
+ PyMac_PRECHECK(LMSetKeyRepThresh);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&value))
return NULL;
{
PyObject *_res = NULL;
UInt8 _rv;
+#ifndef LMGetKbdLast
+ PyMac_PRECHECK(LMGetKbdLast);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = LMGetKbdLast();
{
PyObject *_res = NULL;
UInt8 value;
+#ifndef LMSetKbdLast
+ PyMac_PRECHECK(LMSetKbdLast);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&value))
return NULL;
{
PyObject *_res = NULL;
UInt8 _rv;
+#ifndef LMGetKbdType
+ PyMac_PRECHECK(LMGetKbdType);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = LMGetKbdType();
{
PyObject *_res = NULL;
UInt8 value;
+#ifndef LMSetKbdType
+ PyMac_PRECHECK(LMSetKbdType);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&value))
return NULL;
{
PyObject *_res = NULL;
UInt32 _rv;
+#ifndef TickCount
+ PyMac_PRECHECK(TickCount);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = TickCount();
static PyObject *Fm_InitFonts(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef InitFonts
+ PyMac_PRECHECK(InitFonts);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
InitFonts();
PyObject *_res = NULL;
short familyID;
Str255 name;
+#ifndef GetFontName
+ PyMac_PRECHECK(GetFontName);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&familyID))
return NULL;
PyObject *_res = NULL;
Str255 name;
short familyID;
+#ifndef GetFNum
+ PyMac_PRECHECK(GetFNum);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetStr255, name))
return NULL;
Boolean _rv;
short fontNum;
short size;
+#ifndef RealFont
+ PyMac_PRECHECK(RealFont);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&fontNum,
&size))
{
PyObject *_res = NULL;
Boolean lockFlag;
+#ifndef SetFontLock
+ PyMac_PRECHECK(SetFontLock);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&lockFlag))
return NULL;
{
PyObject *_res = NULL;
Boolean fscaleDisable;
+#ifndef SetFScaleDisable
+ PyMac_PRECHECK(SetFScaleDisable);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&fscaleDisable))
return NULL;
{
PyObject *_res = NULL;
FMetricRec theMetrics;
+#ifndef FontMetrics
+ PyMac_PRECHECK(FontMetrics);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
FontMetrics(&theMetrics);
{
PyObject *_res = NULL;
Boolean fractEnable;
+#ifndef SetFractEnable
+ PyMac_PRECHECK(SetFractEnable);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&fractEnable))
return NULL;
{
PyObject *_res = NULL;
short _rv;
+#ifndef GetDefFontSize
+ PyMac_PRECHECK(GetDefFontSize);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetDefFontSize();
Boolean _rv;
Point numer;
Point denom;
+#ifndef IsOutline
+ PyMac_PRECHECK(IsOutline);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetPoint, &numer,
PyMac_GetPoint, &denom))
{
PyObject *_res = NULL;
Boolean outlinePreferred;
+#ifndef SetOutlinePreferred
+ PyMac_PRECHECK(SetOutlinePreferred);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&outlinePreferred))
return NULL;
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef GetOutlinePreferred
+ PyMac_PRECHECK(GetOutlinePreferred);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetOutlinePreferred();
{
PyObject *_res = NULL;
Boolean preserveGlyph;
+#ifndef SetPreserveGlyph
+ PyMac_PRECHECK(SetPreserveGlyph);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&preserveGlyph))
return NULL;
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef GetPreserveGlyph
+ PyMac_PRECHECK(GetPreserveGlyph);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetPreserveGlyph();
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef FlushFonts
+ PyMac_PRECHECK(FlushFonts);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = FlushFonts();
{
PyObject *_res = NULL;
short _rv;
+#ifndef GetSysFont
+ PyMac_PRECHECK(GetSysFont);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetSysFont();
{
PyObject *_res = NULL;
short _rv;
+#ifndef GetAppFont
+ PyMac_PRECHECK(GetAppFont);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetAppFont();
int inText__len__;
int inText__in_len__;
Rect bounds;
+#ifndef QDTextBounds
+ PyMac_PRECHECK(QDTextBounds);
+#endif
if (!PyArg_ParseTuple(_args, "s#",
&inText__in__, &inText__in_len__))
return NULL;
PyObject *_res = NULL;
CIconHandle _rv;
SInt16 iconID;
+#ifndef GetCIcon
+ PyMac_PRECHECK(GetCIcon);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&iconID))
return NULL;
PyObject *_res = NULL;
Rect theRect;
CIconHandle theIcon;
+#ifndef PlotCIcon
+ PyMac_PRECHECK(PlotCIcon);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetRect, &theRect,
ResObj_Convert, &theIcon))
{
PyObject *_res = NULL;
CIconHandle theIcon;
+#ifndef DisposeCIcon
+ PyMac_PRECHECK(DisposeCIcon);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &theIcon))
return NULL;
PyObject *_res = NULL;
Handle _rv;
SInt16 iconID;
+#ifndef GetIcon
+ PyMac_PRECHECK(GetIcon);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&iconID))
return NULL;
PyObject *_res = NULL;
Rect theRect;
Handle theIcon;
+#ifndef PlotIcon
+ PyMac_PRECHECK(PlotIcon);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetRect, &theRect,
ResObj_Convert, &theIcon))
IconAlignmentType align;
IconTransformType transform;
SInt16 theResID;
+#ifndef PlotIconID
+ PyMac_PRECHECK(PlotIconID);
+#endif
if (!PyArg_ParseTuple(_args, "O&hhh",
PyMac_GetRect, &theRect,
&align,
PyObject *_res = NULL;
OSErr _err;
IconSuiteRef theIconSuite;
+#ifndef NewIconSuite
+ PyMac_PRECHECK(NewIconSuite);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = NewIconSuite(&theIconSuite);
Handle theIconData;
IconSuiteRef theSuite;
ResType theType;
+#ifndef AddIconToSuite
+ PyMac_PRECHECK(AddIconToSuite);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
ResObj_Convert, &theIconData,
ResObj_Convert, &theSuite,
Handle theIconData;
IconSuiteRef theSuite;
ResType theType;
+#ifndef GetIconFromSuite
+ PyMac_PRECHECK(GetIconFromSuite);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &theSuite,
PyMac_GetOSType, &theType))
IconSuiteRef theIconSuite;
SInt16 theResID;
IconSelectorValue selector;
+#ifndef GetIconSuite
+ PyMac_PRECHECK(GetIconSuite);
+#endif
if (!PyArg_ParseTuple(_args, "hl",
&theResID,
&selector))
OSErr _err;
IconSuiteRef theIconSuite;
Boolean disposeData;
+#ifndef DisposeIconSuite
+ PyMac_PRECHECK(DisposeIconSuite);
+#endif
if (!PyArg_ParseTuple(_args, "O&b",
ResObj_Convert, &theIconSuite,
&disposeData))
IconAlignmentType align;
IconTransformType transform;
IconSuiteRef theIconSuite;
+#ifndef PlotIconSuite
+ PyMac_PRECHECK(PlotIconSuite);
+#endif
if (!PyArg_ParseTuple(_args, "O&hhO&",
PyMac_GetRect, &theRect,
&align,
IconAlignmentType align;
IconTransformType transform;
IconCacheRef theIconCache;
+#ifndef LoadIconCache
+ PyMac_PRECHECK(LoadIconCache);
+#endif
if (!PyArg_ParseTuple(_args, "O&hhO&",
PyMac_GetRect, &theRect,
&align,
SInt16 labelNumber;
RGBColor labelColor;
Str255 labelString;
+#ifndef GetLabel
+ PyMac_PRECHECK(GetLabel);
+#endif
if (!PyArg_ParseTuple(_args, "hO&",
&labelNumber,
PyMac_GetStr255, labelString))
Rect iconRect;
IconAlignmentType align;
SInt16 iconID;
+#ifndef PtInIconID
+ PyMac_PRECHECK(PtInIconID);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&hh",
PyMac_GetPoint, &testPt,
PyMac_GetRect, &iconRect,
Rect iconRect;
IconAlignmentType align;
IconSuiteRef theIconSuite;
+#ifndef PtInIconSuite
+ PyMac_PRECHECK(PtInIconSuite);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&hO&",
PyMac_GetPoint, &testPt,
PyMac_GetRect, &iconRect,
Rect iconRect;
IconAlignmentType align;
SInt16 iconID;
+#ifndef RectInIconID
+ PyMac_PRECHECK(RectInIconID);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&hh",
PyMac_GetRect, &testRect,
PyMac_GetRect, &iconRect,
Rect iconRect;
IconAlignmentType align;
IconSuiteRef theIconSuite;
+#ifndef RectInIconSuite
+ PyMac_PRECHECK(RectInIconSuite);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&hO&",
PyMac_GetRect, &testRect,
PyMac_GetRect, &iconRect,
Rect iconRect;
IconAlignmentType align;
SInt16 iconID;
+#ifndef IconIDToRgn
+ PyMac_PRECHECK(IconIDToRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&hh",
ResObj_Convert, &theRgn,
PyMac_GetRect, &iconRect,
Rect iconRect;
IconAlignmentType align;
IconSuiteRef theIconSuite;
+#ifndef IconSuiteToRgn
+ PyMac_PRECHECK(IconSuiteToRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&hO&",
ResObj_Convert, &theRgn,
PyMac_GetRect, &iconRect,
OSErr _err;
IconSuiteRef theSuite;
SInt16 theLabel;
+#ifndef SetSuiteLabel
+ PyMac_PRECHECK(SetSuiteLabel);
+#endif
if (!PyArg_ParseTuple(_args, "O&h",
ResObj_Convert, &theSuite,
&theLabel))
PyObject *_res = NULL;
SInt16 _rv;
IconSuiteRef theSuite;
+#ifndef GetSuiteLabel
+ PyMac_PRECHECK(GetSuiteLabel);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &theSuite))
return NULL;
IconAlignmentType align;
IconTransformType transform;
Handle theIcon;
+#ifndef PlotIconHandle
+ PyMac_PRECHECK(PlotIconHandle);
+#endif
if (!PyArg_ParseTuple(_args, "O&hhO&",
PyMac_GetRect, &theRect,
&align,
IconAlignmentType align;
IconTransformType transform;
Handle theSICN;
+#ifndef PlotSICNHandle
+ PyMac_PRECHECK(PlotSICNHandle);
+#endif
if (!PyArg_ParseTuple(_args, "O&hhO&",
PyMac_GetRect, &theRect,
&align,
IconAlignmentType align;
IconTransformType transform;
CIconHandle theCIcon;
+#ifndef PlotCIconHandle
+ PyMac_PRECHECK(PlotCIconHandle);
+#endif
if (!PyArg_ParseTuple(_args, "O&hhO&",
PyMac_GetRect, &theRect,
&align,
static PyObject *Icn_IconServicesTerminate(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef IconServicesTerminate
+ PyMac_PRECHECK(IconServicesTerminate);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
IconServicesTerminate();
IconRef theIconRef;
IconSelectorValue whichIcons;
IconFamilyHandle iconFamily;
+#ifndef IconRefToIconFamily
+ PyMac_PRECHECK(IconRefToIconFamily);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
ResObj_Convert, &theIconRef,
&whichIcons))
IconFamilyHandle iconFamily;
IconSelectorValue whichIcons;
IconSuiteRef iconSuite;
+#ifndef IconFamilyToIconSuite
+ PyMac_PRECHECK(IconFamilyToIconSuite);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
ResObj_Convert, &iconFamily,
&whichIcons))
IconSuiteRef iconSuite;
IconSelectorValue whichIcons;
IconFamilyHandle iconFamily;
+#ifndef IconSuiteToIconFamily
+ PyMac_PRECHECK(IconSuiteToIconFamily);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
ResObj_Convert, &iconSuite,
&whichIcons))
IconFamilyHandle iconFamily;
OSType iconType;
Handle h;
+#ifndef SetIconFamilyData
+ PyMac_PRECHECK(SetIconFamilyData);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
ResObj_Convert, &iconFamily,
PyMac_GetOSType, &iconType,
IconFamilyHandle iconFamily;
OSType iconType;
Handle h;
+#ifndef GetIconFamilyData
+ PyMac_PRECHECK(GetIconFamilyData);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
ResObj_Convert, &iconFamily,
PyMac_GetOSType, &iconType,
OSErr _err;
IconRef theIconRef;
UInt16 owners;
+#ifndef GetIconRefOwners
+ PyMac_PRECHECK(GetIconRefOwners);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &theIconRef))
return NULL;
PyObject *_res = NULL;
OSErr _err;
IconRef theIconRef;
+#ifndef AcquireIconRef
+ PyMac_PRECHECK(AcquireIconRef);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &theIconRef))
return NULL;
PyObject *_res = NULL;
OSErr _err;
IconRef theIconRef;
+#ifndef ReleaseIconRef
+ PyMac_PRECHECK(ReleaseIconRef);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &theIconRef))
return NULL;
FSSpec theFile;
IconRef theIconRef;
SInt16 theLabel;
+#ifndef GetIconRefFromFile
+ PyMac_PRECHECK(GetIconRefFromFile);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetFSSpec, &theFile))
return NULL;
OSType creator;
OSType iconType;
IconRef theIconRef;
+#ifndef GetIconRef
+ PyMac_PRECHECK(GetIconRef);
+#endif
if (!PyArg_ParseTuple(_args, "hO&O&",
&vRefNum,
PyMac_GetOSType, &creator,
SInt8 attributes;
SInt8 accessPrivileges;
IconRef theIconRef;
+#ifndef GetIconRefFromFolder
+ PyMac_PRECHECK(GetIconRefFromFolder);
+#endif
if (!PyArg_ParseTuple(_args, "hllbb",
&vRefNum,
&parentFolderID,
OSType iconType;
IconFamilyHandle iconFamily;
IconRef theIconRef;
+#ifndef RegisterIconRefFromIconFamily
+ PyMac_PRECHECK(RegisterIconRefFromIconFamily);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
PyMac_GetOSType, &creator,
PyMac_GetOSType, &iconType,
FSSpec resourceFile;
SInt16 resourceID;
IconRef theIconRef;
+#ifndef RegisterIconRefFromResource
+ PyMac_PRECHECK(RegisterIconRefFromResource);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&h",
PyMac_GetOSType, &creator,
PyMac_GetOSType, &iconType,
OSErr _err;
OSType creator;
OSType iconType;
+#ifndef UnregisterIconRef
+ PyMac_PRECHECK(UnregisterIconRef);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetOSType, &creator,
PyMac_GetOSType, &iconType))
PyObject *_res = NULL;
OSErr _err;
IconRef theIconRef;
+#ifndef UpdateIconRef
+ PyMac_PRECHECK(UpdateIconRef);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &theIconRef))
return NULL;
IconRef theIconRef;
FSSpec resourceFile;
SInt16 resourceID;
+#ifndef OverrideIconRefFromResource
+ PyMac_PRECHECK(OverrideIconRefFromResource);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&h",
ResObj_Convert, &theIconRef,
PyMac_GetFSSpec, &resourceFile,
OSErr _err;
IconRef oldIconRef;
IconRef newIconRef;
+#ifndef OverrideIconRef
+ PyMac_PRECHECK(OverrideIconRef);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &oldIconRef,
ResObj_Convert, &newIconRef))
PyObject *_res = NULL;
OSErr _err;
IconRef theIconRef;
+#ifndef RemoveIconRefOverride
+ PyMac_PRECHECK(RemoveIconRefOverride);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &theIconRef))
return NULL;
IconRef backgroundIconRef;
IconRef foregroundIconRef;
IconRef compositeIconRef;
+#ifndef CompositeIconRef
+ PyMac_PRECHECK(CompositeIconRef);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &backgroundIconRef,
ResObj_Convert, &foregroundIconRef))
IconRef compositeIconRef;
IconRef backgroundIconRef;
IconRef foregroundIconRef;
+#ifndef IsIconRefComposite
+ PyMac_PRECHECK(IsIconRefComposite);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &compositeIconRef))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
IconRef theIconRef;
+#ifndef IsValidIconRef
+ PyMac_PRECHECK(IsValidIconRef);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &theIconRef))
return NULL;
IconTransformType transform;
IconServicesUsageFlags theIconServicesUsageFlags;
IconRef theIconRef;
+#ifndef PlotIconRef
+ PyMac_PRECHECK(PlotIconRef);
+#endif
if (!PyArg_ParseTuple(_args, "O&hhlO&",
PyMac_GetRect, &theRect,
&align,
IconAlignmentType align;
IconServicesUsageFlags theIconServicesUsageFlags;
IconRef theIconRef;
+#ifndef PtInIconRef
+ PyMac_PRECHECK(PtInIconRef);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&hlO&",
PyMac_GetPoint, &testPt,
PyMac_GetRect, &iconRect,
IconAlignmentType align;
IconServicesUsageFlags iconServicesUsageFlags;
IconRef theIconRef;
+#ifndef RectInIconRef
+ PyMac_PRECHECK(RectInIconRef);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&hlO&",
PyMac_GetRect, &testRect,
PyMac_GetRect, &iconRect,
IconAlignmentType align;
IconServicesUsageFlags iconServicesUsageFlags;
IconRef theIconRef;
+#ifndef IconRefToRgn
+ PyMac_PRECHECK(IconRefToRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&hlO&",
ResObj_Convert, &theRgn,
PyMac_GetRect, &iconRect,
IconSelectorValue iconSelectorOutputPtr;
IconServicesUsageFlags iconServicesUsageFlags;
IconRef theIconRef;
+#ifndef GetIconSizesFromIconRef
+ PyMac_PRECHECK(GetIconSizesFromIconRef);
+#endif
if (!PyArg_ParseTuple(_args, "llO&",
&iconSelectorInput,
&iconServicesUsageFlags,
OSErr _err;
OSType creator;
OSType iconType;
+#ifndef FlushIconRefs
+ PyMac_PRECHECK(FlushIconRefs);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetOSType, &creator,
PyMac_GetOSType, &iconType))
PyObject *_res = NULL;
OSErr _err;
SInt16 vRefNum;
+#ifndef FlushIconRefsByVolume
+ PyMac_PRECHECK(FlushIconRefsByVolume);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&vRefNum))
return NULL;
OSErr _err;
SInt16 vRefNum;
Boolean enableCustomIcons;
+#ifndef SetCustomIconsEnabled
+ PyMac_PRECHECK(SetCustomIconsEnabled);
+#endif
if (!PyArg_ParseTuple(_args, "hb",
&vRefNum,
&enableCustomIcons))
OSErr _err;
SInt16 vRefNum;
Boolean customIconsEnabled;
+#ifndef GetCustomIconsEnabled
+ PyMac_PRECHECK(GetCustomIconsEnabled);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&vRefNum))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
IconRef iconRef;
+#ifndef IsIconRefMaskEmpty
+ PyMac_PRECHECK(IsIconRefMaskEmpty);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &iconRef))
return NULL;
IconRef inIconRef;
OSType inVariant;
IconTransformType outTransform;
+#ifndef GetIconRefVariant
+ PyMac_PRECHECK(GetIconRefVariant);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &inIconRef,
PyMac_GetOSType, &inVariant))
OSType iconType;
FSSpec iconFile;
IconRef theIconRef;
+#ifndef RegisterIconRefFromIconFile
+ PyMac_PRECHECK(RegisterIconRefFromIconFile);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
PyMac_GetOSType, &creator,
PyMac_GetOSType, &iconType,
OSErr _err;
FSSpec iconFile;
IconFamilyHandle iconFamily;
+#ifndef ReadIconFile
+ PyMac_PRECHECK(ReadIconFile);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetFSSpec, &iconFile))
return NULL;
OSErr _err;
IconFamilyHandle iconFamily;
FSSpec iconFile;
+#ifndef WriteIconFile
+ PyMac_PRECHECK(WriteIconFile);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &iconFamily,
PyMac_GetFSSpec, &iconFile))
{
PyObject *_res = NULL;
GrafPtr port;
+#ifndef MacSetPort
+ PyMac_PRECHECK(MacSetPort);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
{
PyObject *_res = NULL;
GrafPtr port;
+#ifndef GetPort
+ PyMac_PRECHECK(GetPort);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetPort(&port);
{
PyObject *_res = NULL;
short device;
+#ifndef GrafDevice
+ PyMac_PRECHECK(GrafDevice);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&device))
return NULL;
{
PyObject *_res = NULL;
BitMapPtr bm;
+#ifndef SetPortBits
+ PyMac_PRECHECK(SetPortBits);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
BMObj_Convert, &bm))
return NULL;
PyObject *_res = NULL;
short width;
short height;
+#ifndef PortSize
+ PyMac_PRECHECK(PortSize);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&width,
&height))
PyObject *_res = NULL;
short leftGlobal;
short topGlobal;
+#ifndef MovePortTo
+ PyMac_PRECHECK(MovePortTo);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&leftGlobal,
&topGlobal))
PyObject *_res = NULL;
short h;
short v;
+#ifndef SetOrigin
+ PyMac_PRECHECK(SetOrigin);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&h,
&v))
{
PyObject *_res = NULL;
RgnHandle rgn;
+#ifndef SetClip
+ PyMac_PRECHECK(SetClip);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &rgn))
return NULL;
{
PyObject *_res = NULL;
RgnHandle rgn;
+#ifndef GetClip
+ PyMac_PRECHECK(GetClip);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &rgn))
return NULL;
{
PyObject *_res = NULL;
Rect r;
+#ifndef ClipRect
+ PyMac_PRECHECK(ClipRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &r))
return NULL;
PyObject *_res = NULL;
Pattern *pat__in__;
int pat__in_len__;
+#ifndef BackPat
+ PyMac_PRECHECK(BackPat);
+#endif
if (!PyArg_ParseTuple(_args, "s#",
(char **)&pat__in__, &pat__in_len__))
return NULL;
static PyObject *Qd_InitCursor(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef InitCursor
+ PyMac_PRECHECK(InitCursor);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
InitCursor();
PyObject *_res = NULL;
Cursor *crsr__in__;
int crsr__in_len__;
+#ifndef MacSetCursor
+ PyMac_PRECHECK(MacSetCursor);
+#endif
if (!PyArg_ParseTuple(_args, "s#",
(char **)&crsr__in__, &crsr__in_len__))
return NULL;
static PyObject *Qd_HideCursor(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef HideCursor
+ PyMac_PRECHECK(HideCursor);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
HideCursor();
static PyObject *Qd_MacShowCursor(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef MacShowCursor
+ PyMac_PRECHECK(MacShowCursor);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
MacShowCursor();
static PyObject *Qd_ObscureCursor(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef ObscureCursor
+ PyMac_PRECHECK(ObscureCursor);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
ObscureCursor();
static PyObject *Qd_HidePen(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef HidePen
+ PyMac_PRECHECK(HidePen);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
HidePen();
static PyObject *Qd_ShowPen(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef ShowPen
+ PyMac_PRECHECK(ShowPen);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
ShowPen();
{
PyObject *_res = NULL;
Point pt;
+#ifndef GetPen
+ PyMac_PRECHECK(GetPen);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetPen(&pt);
{
PyObject *_res = NULL;
PenState pnState__out__;
+#ifndef GetPenState
+ PyMac_PRECHECK(GetPenState);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetPenState(&pnState__out__);
PyObject *_res = NULL;
PenState *pnState__in__;
int pnState__in_len__;
+#ifndef SetPenState
+ PyMac_PRECHECK(SetPenState);
+#endif
if (!PyArg_ParseTuple(_args, "s#",
(char **)&pnState__in__, &pnState__in_len__))
return NULL;
PyObject *_res = NULL;
short width;
short height;
+#ifndef PenSize
+ PyMac_PRECHECK(PenSize);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&width,
&height))
{
PyObject *_res = NULL;
short mode;
+#ifndef PenMode
+ PyMac_PRECHECK(PenMode);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&mode))
return NULL;
PyObject *_res = NULL;
Pattern *pat__in__;
int pat__in_len__;
+#ifndef PenPat
+ PyMac_PRECHECK(PenPat);
+#endif
if (!PyArg_ParseTuple(_args, "s#",
(char **)&pat__in__, &pat__in_len__))
return NULL;
static PyObject *Qd_PenNormal(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef PenNormal
+ PyMac_PRECHECK(PenNormal);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
PenNormal();
PyObject *_res = NULL;
short h;
short v;
+#ifndef MoveTo
+ PyMac_PRECHECK(MoveTo);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&h,
&v))
PyObject *_res = NULL;
short dh;
short dv;
+#ifndef Move
+ PyMac_PRECHECK(Move);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&dh,
&dv))
PyObject *_res = NULL;
short h;
short v;
+#ifndef MacLineTo
+ PyMac_PRECHECK(MacLineTo);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&h,
&v))
PyObject *_res = NULL;
short dh;
short dv;
+#ifndef Line
+ PyMac_PRECHECK(Line);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&dh,
&dv))
{
PyObject *_res = NULL;
long color;
+#ifndef ForeColor
+ PyMac_PRECHECK(ForeColor);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&color))
return NULL;
{
PyObject *_res = NULL;
long color;
+#ifndef BackColor
+ PyMac_PRECHECK(BackColor);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&color))
return NULL;
{
PyObject *_res = NULL;
short whichBit;
+#ifndef ColorBit
+ PyMac_PRECHECK(ColorBit);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&whichBit))
return NULL;
short top;
short right;
short bottom;
+#ifndef MacSetRect
+ PyMac_PRECHECK(MacSetRect);
+#endif
if (!PyArg_ParseTuple(_args, "hhhh",
&left,
&top,
Rect r;
short dh;
short dv;
+#ifndef MacOffsetRect
+ PyMac_PRECHECK(MacOffsetRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
PyMac_GetRect, &r,
&dh,
Rect r;
short dh;
short dv;
+#ifndef MacInsetRect
+ PyMac_PRECHECK(MacInsetRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
PyMac_GetRect, &r,
&dh,
Rect src1;
Rect src2;
Rect dstRect;
+#ifndef SectRect
+ PyMac_PRECHECK(SectRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetRect, &src1,
PyMac_GetRect, &src2))
Rect src1;
Rect src2;
Rect dstRect;
+#ifndef MacUnionRect
+ PyMac_PRECHECK(MacUnionRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetRect, &src1,
PyMac_GetRect, &src2))
Boolean _rv;
Rect rect1;
Rect rect2;
+#ifndef MacEqualRect
+ PyMac_PRECHECK(MacEqualRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetRect, &rect1,
PyMac_GetRect, &rect2))
PyObject *_res = NULL;
Boolean _rv;
Rect r;
+#ifndef EmptyRect
+ PyMac_PRECHECK(EmptyRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &r))
return NULL;
{
PyObject *_res = NULL;
Rect r;
+#ifndef MacFrameRect
+ PyMac_PRECHECK(MacFrameRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &r))
return NULL;
{
PyObject *_res = NULL;
Rect r;
+#ifndef PaintRect
+ PyMac_PRECHECK(PaintRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &r))
return NULL;
{
PyObject *_res = NULL;
Rect r;
+#ifndef EraseRect
+ PyMac_PRECHECK(EraseRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &r))
return NULL;
{
PyObject *_res = NULL;
Rect r;
+#ifndef MacInvertRect
+ PyMac_PRECHECK(MacInvertRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &r))
return NULL;
Rect r;
Pattern *pat__in__;
int pat__in_len__;
+#ifndef MacFillRect
+ PyMac_PRECHECK(MacFillRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&s#",
PyMac_GetRect, &r,
(char **)&pat__in__, &pat__in_len__))
{
PyObject *_res = NULL;
Rect r;
+#ifndef FrameOval
+ PyMac_PRECHECK(FrameOval);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &r))
return NULL;
{
PyObject *_res = NULL;
Rect r;
+#ifndef PaintOval
+ PyMac_PRECHECK(PaintOval);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &r))
return NULL;
{
PyObject *_res = NULL;
Rect r;
+#ifndef EraseOval
+ PyMac_PRECHECK(EraseOval);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &r))
return NULL;
{
PyObject *_res = NULL;
Rect r;
+#ifndef InvertOval
+ PyMac_PRECHECK(InvertOval);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &r))
return NULL;
Rect r;
Pattern *pat__in__;
int pat__in_len__;
+#ifndef FillOval
+ PyMac_PRECHECK(FillOval);
+#endif
if (!PyArg_ParseTuple(_args, "O&s#",
PyMac_GetRect, &r,
(char **)&pat__in__, &pat__in_len__))
Rect r;
short ovalWidth;
short ovalHeight;
+#ifndef FrameRoundRect
+ PyMac_PRECHECK(FrameRoundRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
PyMac_GetRect, &r,
&ovalWidth,
Rect r;
short ovalWidth;
short ovalHeight;
+#ifndef PaintRoundRect
+ PyMac_PRECHECK(PaintRoundRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
PyMac_GetRect, &r,
&ovalWidth,
Rect r;
short ovalWidth;
short ovalHeight;
+#ifndef EraseRoundRect
+ PyMac_PRECHECK(EraseRoundRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
PyMac_GetRect, &r,
&ovalWidth,
Rect r;
short ovalWidth;
short ovalHeight;
+#ifndef InvertRoundRect
+ PyMac_PRECHECK(InvertRoundRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
PyMac_GetRect, &r,
&ovalWidth,
short ovalHeight;
Pattern *pat__in__;
int pat__in_len__;
+#ifndef FillRoundRect
+ PyMac_PRECHECK(FillRoundRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&hhs#",
PyMac_GetRect, &r,
&ovalWidth,
Rect r;
short startAngle;
short arcAngle;
+#ifndef FrameArc
+ PyMac_PRECHECK(FrameArc);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
PyMac_GetRect, &r,
&startAngle,
Rect r;
short startAngle;
short arcAngle;
+#ifndef PaintArc
+ PyMac_PRECHECK(PaintArc);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
PyMac_GetRect, &r,
&startAngle,
Rect r;
short startAngle;
short arcAngle;
+#ifndef EraseArc
+ PyMac_PRECHECK(EraseArc);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
PyMac_GetRect, &r,
&startAngle,
Rect r;
short startAngle;
short arcAngle;
+#ifndef InvertArc
+ PyMac_PRECHECK(InvertArc);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
PyMac_GetRect, &r,
&startAngle,
short arcAngle;
Pattern *pat__in__;
int pat__in_len__;
+#ifndef FillArc
+ PyMac_PRECHECK(FillArc);
+#endif
if (!PyArg_ParseTuple(_args, "O&hhs#",
PyMac_GetRect, &r,
&startAngle,
{
PyObject *_res = NULL;
RgnHandle _rv;
+#ifndef NewRgn
+ PyMac_PRECHECK(NewRgn);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = NewRgn();
static PyObject *Qd_OpenRgn(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef OpenRgn
+ PyMac_PRECHECK(OpenRgn);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
OpenRgn();
{
PyObject *_res = NULL;
RgnHandle dstRgn;
+#ifndef CloseRgn
+ PyMac_PRECHECK(CloseRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &dstRgn))
return NULL;
OSErr _err;
RgnHandle region;
BitMapPtr bMap;
+#ifndef BitMapToRegion
+ PyMac_PRECHECK(BitMapToRegion);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, ®ion,
BMObj_Convert, &bMap))
PyObject *_res = NULL;
RgnHandle region;
Handle flattenedRgnDataHdl;
+#ifndef RgnToHandle
+ PyMac_PRECHECK(RgnToHandle);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, ®ion,
ResObj_Convert, &flattenedRgnDataHdl))
{
PyObject *_res = NULL;
RgnHandle rgn;
+#ifndef DisposeRgn
+ PyMac_PRECHECK(DisposeRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &rgn))
return NULL;
PyObject *_res = NULL;
RgnHandle srcRgn;
RgnHandle dstRgn;
+#ifndef MacCopyRgn
+ PyMac_PRECHECK(MacCopyRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &srcRgn,
ResObj_Convert, &dstRgn))
{
PyObject *_res = NULL;
RgnHandle rgn;
+#ifndef SetEmptyRgn
+ PyMac_PRECHECK(SetEmptyRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &rgn))
return NULL;
short top;
short right;
short bottom;
+#ifndef MacSetRectRgn
+ PyMac_PRECHECK(MacSetRectRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&hhhh",
ResObj_Convert, &rgn,
&left,
PyObject *_res = NULL;
RgnHandle rgn;
Rect r;
+#ifndef RectRgn
+ PyMac_PRECHECK(RectRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &rgn,
PyMac_GetRect, &r))
RgnHandle rgn;
short dh;
short dv;
+#ifndef MacOffsetRgn
+ PyMac_PRECHECK(MacOffsetRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
ResObj_Convert, &rgn,
&dh,
RgnHandle rgn;
short dh;
short dv;
+#ifndef InsetRgn
+ PyMac_PRECHECK(InsetRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
ResObj_Convert, &rgn,
&dh,
RgnHandle srcRgnA;
RgnHandle srcRgnB;
RgnHandle dstRgn;
+#ifndef SectRgn
+ PyMac_PRECHECK(SectRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
ResObj_Convert, &srcRgnA,
ResObj_Convert, &srcRgnB,
RgnHandle srcRgnA;
RgnHandle srcRgnB;
RgnHandle dstRgn;
+#ifndef MacUnionRgn
+ PyMac_PRECHECK(MacUnionRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
ResObj_Convert, &srcRgnA,
ResObj_Convert, &srcRgnB,
RgnHandle srcRgnA;
RgnHandle srcRgnB;
RgnHandle dstRgn;
+#ifndef DiffRgn
+ PyMac_PRECHECK(DiffRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
ResObj_Convert, &srcRgnA,
ResObj_Convert, &srcRgnB,
RgnHandle srcRgnA;
RgnHandle srcRgnB;
RgnHandle dstRgn;
+#ifndef MacXorRgn
+ PyMac_PRECHECK(MacXorRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
ResObj_Convert, &srcRgnA,
ResObj_Convert, &srcRgnB,
Boolean _rv;
Rect r;
RgnHandle rgn;
+#ifndef RectInRgn
+ PyMac_PRECHECK(RectInRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetRect, &r,
ResObj_Convert, &rgn))
Boolean _rv;
RgnHandle rgnA;
RgnHandle rgnB;
+#ifndef MacEqualRgn
+ PyMac_PRECHECK(MacEqualRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &rgnA,
ResObj_Convert, &rgnB))
PyObject *_res = NULL;
Boolean _rv;
RgnHandle rgn;
+#ifndef EmptyRgn
+ PyMac_PRECHECK(EmptyRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &rgn))
return NULL;
{
PyObject *_res = NULL;
RgnHandle rgn;
+#ifndef MacFrameRgn
+ PyMac_PRECHECK(MacFrameRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &rgn))
return NULL;
{
PyObject *_res = NULL;
RgnHandle rgn;
+#ifndef MacPaintRgn
+ PyMac_PRECHECK(MacPaintRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &rgn))
return NULL;
{
PyObject *_res = NULL;
RgnHandle rgn;
+#ifndef EraseRgn
+ PyMac_PRECHECK(EraseRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &rgn))
return NULL;
{
PyObject *_res = NULL;
RgnHandle rgn;
+#ifndef MacInvertRgn
+ PyMac_PRECHECK(MacInvertRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &rgn))
return NULL;
RgnHandle rgn;
Pattern *pat__in__;
int pat__in_len__;
+#ifndef MacFillRgn
+ PyMac_PRECHECK(MacFillRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&s#",
ResObj_Convert, &rgn,
(char **)&pat__in__, &pat__in_len__))
short dh;
short dv;
RgnHandle updateRgn;
+#ifndef ScrollRect
+ PyMac_PRECHECK(ScrollRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&hhO&",
PyMac_GetRect, &r,
&dh,
Rect dstRect;
short mode;
RgnHandle maskRgn;
+#ifndef CopyBits
+ PyMac_PRECHECK(CopyBits);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&O&hO&",
BMObj_Convert, &srcBits,
BMObj_Convert, &dstBits,
Rect srcRect;
Rect maskRect;
Rect dstRect;
+#ifndef CopyMask
+ PyMac_PRECHECK(CopyMask);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&O&O&O&",
BMObj_Convert, &srcBits,
BMObj_Convert, &maskBits,
PyObject *_res = NULL;
PicHandle _rv;
Rect picFrame;
+#ifndef OpenPicture
+ PyMac_PRECHECK(OpenPicture);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &picFrame))
return NULL;
short kind;
short dataSize;
Handle dataHandle;
+#ifndef PicComment
+ PyMac_PRECHECK(PicComment);
+#endif
if (!PyArg_ParseTuple(_args, "hhO&",
&kind,
&dataSize,
static PyObject *Qd_ClosePicture(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef ClosePicture
+ PyMac_PRECHECK(ClosePicture);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
ClosePicture();
PyObject *_res = NULL;
PicHandle myPicture;
Rect dstRect;
+#ifndef DrawPicture
+ PyMac_PRECHECK(DrawPicture);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &myPicture,
PyMac_GetRect, &dstRect))
{
PyObject *_res = NULL;
PicHandle myPicture;
+#ifndef KillPicture
+ PyMac_PRECHECK(KillPicture);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &myPicture))
return NULL;
{
PyObject *_res = NULL;
PolyHandle _rv;
+#ifndef OpenPoly
+ PyMac_PRECHECK(OpenPoly);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = OpenPoly();
static PyObject *Qd_ClosePoly(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef ClosePoly
+ PyMac_PRECHECK(ClosePoly);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
ClosePoly();
{
PyObject *_res = NULL;
PolyHandle poly;
+#ifndef KillPoly
+ PyMac_PRECHECK(KillPoly);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &poly))
return NULL;
PolyHandle poly;
short dh;
short dv;
+#ifndef OffsetPoly
+ PyMac_PRECHECK(OffsetPoly);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
ResObj_Convert, &poly,
&dh,
{
PyObject *_res = NULL;
PolyHandle poly;
+#ifndef FramePoly
+ PyMac_PRECHECK(FramePoly);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &poly))
return NULL;
{
PyObject *_res = NULL;
PolyHandle poly;
+#ifndef PaintPoly
+ PyMac_PRECHECK(PaintPoly);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &poly))
return NULL;
{
PyObject *_res = NULL;
PolyHandle poly;
+#ifndef ErasePoly
+ PyMac_PRECHECK(ErasePoly);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &poly))
return NULL;
{
PyObject *_res = NULL;
PolyHandle poly;
+#ifndef InvertPoly
+ PyMac_PRECHECK(InvertPoly);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &poly))
return NULL;
PolyHandle poly;
Pattern *pat__in__;
int pat__in_len__;
+#ifndef FillPoly
+ PyMac_PRECHECK(FillPoly);
+#endif
if (!PyArg_ParseTuple(_args, "O&s#",
ResObj_Convert, &poly,
(char **)&pat__in__, &pat__in_len__))
Point pt;
short h;
short v;
+#ifndef SetPt
+ PyMac_PRECHECK(SetPt);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&h,
&v))
{
PyObject *_res = NULL;
Point pt;
+#ifndef LocalToGlobal
+ PyMac_PRECHECK(LocalToGlobal);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetPoint, &pt))
return NULL;
{
PyObject *_res = NULL;
Point pt;
+#ifndef GlobalToLocal
+ PyMac_PRECHECK(GlobalToLocal);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetPoint, &pt))
return NULL;
{
PyObject *_res = NULL;
short _rv;
+#ifndef Random
+ PyMac_PRECHECK(Random);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = Random();
Boolean _rv;
short h;
short v;
+#ifndef MacGetPixel
+ PyMac_PRECHECK(MacGetPixel);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&h,
&v))
Point pt;
Rect srcRect;
Rect dstRect;
+#ifndef ScalePt
+ PyMac_PRECHECK(ScalePt);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
PyMac_GetPoint, &pt,
PyMac_GetRect, &srcRect,
Point pt;
Rect srcRect;
Rect dstRect;
+#ifndef MapPt
+ PyMac_PRECHECK(MapPt);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
PyMac_GetPoint, &pt,
PyMac_GetRect, &srcRect,
Rect r;
Rect srcRect;
Rect dstRect;
+#ifndef MapRect
+ PyMac_PRECHECK(MapRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
PyMac_GetRect, &r,
PyMac_GetRect, &srcRect,
RgnHandle rgn;
Rect srcRect;
Rect dstRect;
+#ifndef MapRgn
+ PyMac_PRECHECK(MapRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
ResObj_Convert, &rgn,
PyMac_GetRect, &srcRect,
PolyHandle poly;
Rect srcRect;
Rect dstRect;
+#ifndef MapPoly
+ PyMac_PRECHECK(MapPoly);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
ResObj_Convert, &poly,
PyMac_GetRect, &srcRect,
Rect dstRect;
short mode;
RgnHandle maskRgn;
+#ifndef StdBits
+ PyMac_PRECHECK(StdBits);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&hO&",
BMObj_Convert, &srcBits,
PyMac_GetRect, &srcRect,
PyObject *_res = NULL;
Point src;
Point dst;
+#ifndef AddPt
+ PyMac_PRECHECK(AddPt);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetPoint, &src,
PyMac_GetPoint, &dst))
Boolean _rv;
Point pt1;
Point pt2;
+#ifndef EqualPt
+ PyMac_PRECHECK(EqualPt);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetPoint, &pt1,
PyMac_GetPoint, &pt2))
Boolean _rv;
Point pt;
Rect r;
+#ifndef MacPtInRect
+ PyMac_PRECHECK(MacPtInRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetPoint, &pt,
PyMac_GetRect, &r))
Point pt1;
Point pt2;
Rect dstRect;
+#ifndef Pt2Rect
+ PyMac_PRECHECK(Pt2Rect);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetPoint, &pt1,
PyMac_GetPoint, &pt2))
Rect r;
Point pt;
short angle;
+#ifndef PtToAngle
+ PyMac_PRECHECK(PtToAngle);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetRect, &r,
PyMac_GetPoint, &pt))
PyObject *_res = NULL;
Point src;
Point dst;
+#ifndef SubPt
+ PyMac_PRECHECK(SubPt);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetPoint, &src,
PyMac_GetPoint, &dst))
Boolean _rv;
Point pt;
RgnHandle rgn;
+#ifndef PtInRgn
+ PyMac_PRECHECK(PtInRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetPoint, &pt,
ResObj_Convert, &rgn))
{
PyObject *_res = NULL;
PixMapHandle _rv;
+#ifndef NewPixMap
+ PyMac_PRECHECK(NewPixMap);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = NewPixMap();
{
PyObject *_res = NULL;
PixMapHandle pm;
+#ifndef DisposePixMap
+ PyMac_PRECHECK(DisposePixMap);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &pm))
return NULL;
PyObject *_res = NULL;
PixMapHandle srcPM;
PixMapHandle dstPM;
+#ifndef CopyPixMap
+ PyMac_PRECHECK(CopyPixMap);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &srcPM,
ResObj_Convert, &dstPM))
{
PyObject *_res = NULL;
PixPatHandle _rv;
+#ifndef NewPixPat
+ PyMac_PRECHECK(NewPixPat);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = NewPixPat();
{
PyObject *_res = NULL;
PixPatHandle pp;
+#ifndef DisposePixPat
+ PyMac_PRECHECK(DisposePixPat);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &pp))
return NULL;
PyObject *_res = NULL;
PixPatHandle srcPP;
PixPatHandle dstPP;
+#ifndef CopyPixPat
+ PyMac_PRECHECK(CopyPixPat);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &srcPP,
ResObj_Convert, &dstPP))
{
PyObject *_res = NULL;
PixPatHandle pp;
+#ifndef PenPixPat
+ PyMac_PRECHECK(PenPixPat);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &pp))
return NULL;
{
PyObject *_res = NULL;
PixPatHandle pp;
+#ifndef BackPixPat
+ PyMac_PRECHECK(BackPixPat);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &pp))
return NULL;
PyObject *_res = NULL;
PixPatHandle _rv;
short patID;
+#ifndef GetPixPat
+ PyMac_PRECHECK(GetPixPat);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&patID))
return NULL;
PyObject *_res = NULL;
PixPatHandle pp;
RGBColor myColor;
+#ifndef MakeRGBPat
+ PyMac_PRECHECK(MakeRGBPat);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &pp,
QdRGB_Convert, &myColor))
PyObject *_res = NULL;
Rect r;
PixPatHandle pp;
+#ifndef FillCRect
+ PyMac_PRECHECK(FillCRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetRect, &r,
ResObj_Convert, &pp))
PyObject *_res = NULL;
Rect r;
PixPatHandle pp;
+#ifndef FillCOval
+ PyMac_PRECHECK(FillCOval);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetRect, &r,
ResObj_Convert, &pp))
short ovalWidth;
short ovalHeight;
PixPatHandle pp;
+#ifndef FillCRoundRect
+ PyMac_PRECHECK(FillCRoundRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&hhO&",
PyMac_GetRect, &r,
&ovalWidth,
short startAngle;
short arcAngle;
PixPatHandle pp;
+#ifndef FillCArc
+ PyMac_PRECHECK(FillCArc);
+#endif
if (!PyArg_ParseTuple(_args, "O&hhO&",
PyMac_GetRect, &r,
&startAngle,
PyObject *_res = NULL;
RgnHandle rgn;
PixPatHandle pp;
+#ifndef FillCRgn
+ PyMac_PRECHECK(FillCRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &rgn,
ResObj_Convert, &pp))
PyObject *_res = NULL;
PolyHandle poly;
PixPatHandle pp;
+#ifndef FillCPoly
+ PyMac_PRECHECK(FillCPoly);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &poly,
ResObj_Convert, &pp))
{
PyObject *_res = NULL;
RGBColor color;
+#ifndef RGBForeColor
+ PyMac_PRECHECK(RGBForeColor);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
QdRGB_Convert, &color))
return NULL;
{
PyObject *_res = NULL;
RGBColor color;
+#ifndef RGBBackColor
+ PyMac_PRECHECK(RGBBackColor);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
QdRGB_Convert, &color))
return NULL;
short h;
short v;
RGBColor cPix;
+#ifndef SetCPixel
+ PyMac_PRECHECK(SetCPixel);
+#endif
if (!PyArg_ParseTuple(_args, "hhO&",
&h,
&v,
{
PyObject *_res = NULL;
PixMapHandle pm;
+#ifndef SetPortPix
+ PyMac_PRECHECK(SetPortPix);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &pm))
return NULL;
short h;
short v;
RGBColor cPix;
+#ifndef GetCPixel
+ PyMac_PRECHECK(GetCPixel);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&h,
&v))
{
PyObject *_res = NULL;
RGBColor color;
+#ifndef GetForeColor
+ PyMac_PRECHECK(GetForeColor);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetForeColor(&color);
{
PyObject *_res = NULL;
RGBColor color;
+#ifndef GetBackColor
+ PyMac_PRECHECK(GetBackColor);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetBackColor(&color);
{
PyObject *_res = NULL;
RGBColor color;
+#ifndef OpColor
+ PyMac_PRECHECK(OpColor);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
QdRGB_Convert, &color))
return NULL;
{
PyObject *_res = NULL;
RGBColor color;
+#ifndef HiliteColor
+ PyMac_PRECHECK(HiliteColor);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
QdRGB_Convert, &color))
return NULL;
{
PyObject *_res = NULL;
CTabHandle cTable;
+#ifndef DisposeCTable
+ PyMac_PRECHECK(DisposeCTable);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &cTable))
return NULL;
PyObject *_res = NULL;
CTabHandle _rv;
short ctID;
+#ifndef GetCTable
+ PyMac_PRECHECK(GetCTable);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&ctID))
return NULL;
PyObject *_res = NULL;
CCrsrHandle _rv;
short crsrID;
+#ifndef GetCCursor
+ PyMac_PRECHECK(GetCCursor);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&crsrID))
return NULL;
{
PyObject *_res = NULL;
CCrsrHandle cCrsr;
+#ifndef SetCCursor
+ PyMac_PRECHECK(SetCCursor);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &cCrsr))
return NULL;
static PyObject *Qd_AllocCursor(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef AllocCursor
+ PyMac_PRECHECK(AllocCursor);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
AllocCursor();
{
PyObject *_res = NULL;
CCrsrHandle cCrsr;
+#ifndef DisposeCCursor
+ PyMac_PRECHECK(DisposeCCursor);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &cCrsr))
return NULL;
PyObject *_res = NULL;
GDHandle _rv;
Rect globalRect;
+#ifndef GetMaxDevice
+ PyMac_PRECHECK(GetMaxDevice);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &globalRect))
return NULL;
{
PyObject *_res = NULL;
long _rv;
+#ifndef GetCTSeed
+ PyMac_PRECHECK(GetCTSeed);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetCTSeed();
{
PyObject *_res = NULL;
GDHandle _rv;
+#ifndef GetDeviceList
+ PyMac_PRECHECK(GetDeviceList);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetDeviceList();
{
PyObject *_res = NULL;
GDHandle _rv;
+#ifndef GetMainDevice
+ PyMac_PRECHECK(GetMainDevice);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMainDevice();
PyObject *_res = NULL;
GDHandle _rv;
GDHandle curDevice;
+#ifndef GetNextDevice
+ PyMac_PRECHECK(GetNextDevice);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &curDevice))
return NULL;
Boolean _rv;
GDHandle gdh;
short attribute;
+#ifndef TestDeviceAttribute
+ PyMac_PRECHECK(TestDeviceAttribute);
+#endif
if (!PyArg_ParseTuple(_args, "O&h",
ResObj_Convert, &gdh,
&attribute))
GDHandle gdh;
short attribute;
Boolean value;
+#ifndef SetDeviceAttribute
+ PyMac_PRECHECK(SetDeviceAttribute);
+#endif
if (!PyArg_ParseTuple(_args, "O&hb",
ResObj_Convert, &gdh,
&attribute,
short qdRefNum;
long mode;
GDHandle gdh;
+#ifndef InitGDevice
+ PyMac_PRECHECK(InitGDevice);
+#endif
if (!PyArg_ParseTuple(_args, "hlO&",
&qdRefNum,
&mode,
GDHandle _rv;
short refNum;
long mode;
+#ifndef NewGDevice
+ PyMac_PRECHECK(NewGDevice);
+#endif
if (!PyArg_ParseTuple(_args, "hl",
&refNum,
&mode))
{
PyObject *_res = NULL;
GDHandle gdh;
+#ifndef DisposeGDevice
+ PyMac_PRECHECK(DisposeGDevice);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &gdh))
return NULL;
{
PyObject *_res = NULL;
GDHandle gd;
+#ifndef SetGDevice
+ PyMac_PRECHECK(SetGDevice);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &gd))
return NULL;
{
PyObject *_res = NULL;
GDHandle _rv;
+#ifndef GetGDevice
+ PyMac_PRECHECK(GetGDevice);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetGDevice();
PyObject *_res = NULL;
long _rv;
RGBColor myColor;
+#ifndef Color2Index
+ PyMac_PRECHECK(Color2Index);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
QdRGB_Convert, &myColor))
return NULL;
PyObject *_res = NULL;
long index;
RGBColor aColor;
+#ifndef Index2Color
+ PyMac_PRECHECK(Index2Color);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&index))
return NULL;
{
PyObject *_res = NULL;
RGBColor myColor;
+#ifndef InvertColor
+ PyMac_PRECHECK(InvertColor);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
InvertColor(&myColor);
PyObject *_res = NULL;
Boolean _rv;
RGBColor color;
+#ifndef RealColor
+ PyMac_PRECHECK(RealColor);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
QdRGB_Convert, &color))
return NULL;
CTabHandle myColors;
short iTabRes;
CTabHandle targetTbl;
+#ifndef GetSubTable
+ PyMac_PRECHECK(GetSubTable);
+#endif
if (!PyArg_ParseTuple(_args, "O&hO&",
ResObj_Convert, &myColors,
&iTabRes,
CTabHandle cTabH;
ITabHandle iTabH;
short res;
+#ifndef MakeITable
+ PyMac_PRECHECK(MakeITable);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&h",
ResObj_Convert, &cTabH,
ResObj_Convert, &iTabH,
{
PyObject *_res = NULL;
short id;
+#ifndef SetClientID
+ PyMac_PRECHECK(SetClientID);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&id))
return NULL;
PyObject *_res = NULL;
short index;
Boolean protect;
+#ifndef ProtectEntry
+ PyMac_PRECHECK(ProtectEntry);
+#endif
if (!PyArg_ParseTuple(_args, "hb",
&index,
&protect))
PyObject *_res = NULL;
short index;
Boolean reserve;
+#ifndef ReserveEntry
+ PyMac_PRECHECK(ReserveEntry);
+#endif
if (!PyArg_ParseTuple(_args, "hb",
&index,
&reserve))
{
PyObject *_res = NULL;
short _rv;
+#ifndef QDError
+ PyMac_PRECHECK(QDError);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = QDError();
Rect dstRect;
short mode;
RgnHandle maskRgn;
+#ifndef CopyDeepMask
+ PyMac_PRECHECK(CopyDeepMask);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&O&O&O&hO&",
BMObj_Convert, &srcBits,
BMObj_Convert, &maskBits,
PyObject *_res = NULL;
PatHandle _rv;
short patternID;
+#ifndef GetPattern
+ PyMac_PRECHECK(GetPattern);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&patternID))
return NULL;
PyObject *_res = NULL;
CursHandle _rv;
short cursorID;
+#ifndef MacGetCursor
+ PyMac_PRECHECK(MacGetCursor);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&cursorID))
return NULL;
PyObject *_res = NULL;
PicHandle _rv;
short pictureID;
+#ifndef GetPicture
+ PyMac_PRECHECK(GetPicture);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&pictureID))
return NULL;
long _rv;
Point ptA;
Point ptB;
+#ifndef DeltaPoint
+ PyMac_PRECHECK(DeltaPoint);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetPoint, &ptA,
PyMac_GetPoint, &ptB))
PyObject *_res = NULL;
Rect shieldRect;
Point offsetPt;
+#ifndef ShieldCursor
+ PyMac_PRECHECK(ShieldCursor);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetRect, &shieldRect,
PyMac_GetPoint, &offsetPt))
PyObject *_res = NULL;
short scrnHRes;
short scrnVRes;
+#ifndef ScreenRes
+ PyMac_PRECHECK(ScreenRes);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
ScreenRes(&scrnHRes,
Pattern thePat__out__;
short patternListID;
short index;
+#ifndef GetIndPattern
+ PyMac_PRECHECK(GetIndPattern);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&patternListID,
&index))
PyObject *_res = NULL;
Fixed _rv;
short angle;
+#ifndef SlopeFromAngle
+ PyMac_PRECHECK(SlopeFromAngle);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&angle))
return NULL;
PyObject *_res = NULL;
short _rv;
Fixed slope;
+#ifndef AngleFromSlope
+ PyMac_PRECHECK(AngleFromSlope);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetFixed, &slope))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
CGrafPtr port;
+#ifndef IsValidPort
+ PyMac_PRECHECK(IsValidPort);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
PixMapHandle _rv;
CGrafPtr port;
+#ifndef GetPortPixMap
+ PyMac_PRECHECK(GetPortPixMap);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
const BitMap * _rv;
CGrafPtr port;
+#ifndef GetPortBitMapForCopyBits
+ PyMac_PRECHECK(GetPortBitMapForCopyBits);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
CGrafPtr port;
Rect rect;
+#ifndef GetPortBounds
+ PyMac_PRECHECK(GetPortBounds);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
CGrafPtr port;
RGBColor foreColor;
+#ifndef GetPortForeColor
+ PyMac_PRECHECK(GetPortForeColor);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
CGrafPtr port;
RGBColor backColor;
+#ifndef GetPortBackColor
+ PyMac_PRECHECK(GetPortBackColor);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
CGrafPtr port;
RGBColor opColor;
+#ifndef GetPortOpColor
+ PyMac_PRECHECK(GetPortOpColor);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
CGrafPtr port;
RGBColor hiliteColor;
+#ifndef GetPortHiliteColor
+ PyMac_PRECHECK(GetPortHiliteColor);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
short _rv;
CGrafPtr port;
+#ifndef GetPortTextFont
+ PyMac_PRECHECK(GetPortTextFont);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
Style _rv;
CGrafPtr port;
+#ifndef GetPortTextFace
+ PyMac_PRECHECK(GetPortTextFace);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
short _rv;
CGrafPtr port;
+#ifndef GetPortTextMode
+ PyMac_PRECHECK(GetPortTextMode);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
short _rv;
CGrafPtr port;
+#ifndef GetPortTextSize
+ PyMac_PRECHECK(GetPortTextSize);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
short _rv;
CGrafPtr port;
+#ifndef GetPortChExtra
+ PyMac_PRECHECK(GetPortChExtra);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
short _rv;
CGrafPtr port;
+#ifndef GetPortFracHPenLocation
+ PyMac_PRECHECK(GetPortFracHPenLocation);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
Fixed _rv;
CGrafPtr port;
+#ifndef GetPortSpExtra
+ PyMac_PRECHECK(GetPortSpExtra);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
short _rv;
CGrafPtr port;
+#ifndef GetPortPenVisibility
+ PyMac_PRECHECK(GetPortPenVisibility);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
RgnHandle _rv;
CGrafPtr port;
RgnHandle visRgn;
+#ifndef GetPortVisibleRegion
+ PyMac_PRECHECK(GetPortVisibleRegion);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
ResObj_Convert, &visRgn))
RgnHandle _rv;
CGrafPtr port;
RgnHandle clipRgn;
+#ifndef GetPortClipRegion
+ PyMac_PRECHECK(GetPortClipRegion);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
ResObj_Convert, &clipRgn))
PixPatHandle _rv;
CGrafPtr port;
PixPatHandle backPattern;
+#ifndef GetPortBackPixPat
+ PyMac_PRECHECK(GetPortBackPixPat);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
ResObj_Convert, &backPattern))
PixPatHandle _rv;
CGrafPtr port;
PixPatHandle penPattern;
+#ifndef GetPortPenPixPat
+ PyMac_PRECHECK(GetPortPenPixPat);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
ResObj_Convert, &penPattern))
PixPatHandle _rv;
CGrafPtr port;
PixPatHandle fillPattern;
+#ifndef GetPortFillPixPat
+ PyMac_PRECHECK(GetPortFillPixPat);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
ResObj_Convert, &fillPattern))
PyObject *_res = NULL;
CGrafPtr port;
Point penSize;
+#ifndef GetPortPenSize
+ PyMac_PRECHECK(GetPortPenSize);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
PyMac_GetPoint, &penSize))
PyObject *_res = NULL;
SInt32 _rv;
CGrafPtr port;
+#ifndef GetPortPenMode
+ PyMac_PRECHECK(GetPortPenMode);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
CGrafPtr port;
Point penLocation;
+#ifndef GetPortPenLocation
+ PyMac_PRECHECK(GetPortPenLocation);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
PyMac_GetPoint, &penLocation))
PyObject *_res = NULL;
Boolean _rv;
CGrafPtr port;
+#ifndef IsPortRegionBeingDefined
+ PyMac_PRECHECK(IsPortRegionBeingDefined);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
CGrafPtr port;
+#ifndef IsPortPictureBeingDefined
+ PyMac_PRECHECK(IsPortPictureBeingDefined);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
CGrafPtr port;
+#ifndef IsPortPolyBeingDefined
+ PyMac_PRECHECK(IsPortPolyBeingDefined);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
CGrafPtr port;
+#ifndef IsPortOffscreen
+ PyMac_PRECHECK(IsPortOffscreen);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
CGrafPtr port;
+#ifndef IsPortColor
+ PyMac_PRECHECK(IsPortColor);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
CGrafPtr port;
Rect rect;
+#ifndef SetPortBounds
+ PyMac_PRECHECK(SetPortBounds);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
PyMac_GetRect, &rect))
PyObject *_res = NULL;
CGrafPtr port;
RGBColor opColor;
+#ifndef SetPortOpColor
+ PyMac_PRECHECK(SetPortOpColor);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
QdRGB_Convert, &opColor))
PyObject *_res = NULL;
CGrafPtr port;
RgnHandle visRgn;
+#ifndef SetPortVisibleRegion
+ PyMac_PRECHECK(SetPortVisibleRegion);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
ResObj_Convert, &visRgn))
PyObject *_res = NULL;
CGrafPtr port;
RgnHandle clipRgn;
+#ifndef SetPortClipRegion
+ PyMac_PRECHECK(SetPortClipRegion);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
ResObj_Convert, &clipRgn))
PyObject *_res = NULL;
CGrafPtr port;
PixPatHandle penPattern;
+#ifndef SetPortPenPixPat
+ PyMac_PRECHECK(SetPortPenPixPat);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
ResObj_Convert, &penPattern))
PyObject *_res = NULL;
CGrafPtr port;
PixPatHandle penPattern;
+#ifndef SetPortFillPixPat
+ PyMac_PRECHECK(SetPortFillPixPat);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
ResObj_Convert, &penPattern))
PyObject *_res = NULL;
CGrafPtr port;
PixPatHandle backPattern;
+#ifndef SetPortBackPixPat
+ PyMac_PRECHECK(SetPortBackPixPat);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
ResObj_Convert, &backPattern))
PyObject *_res = NULL;
CGrafPtr port;
Point penSize;
+#ifndef SetPortPenSize
+ PyMac_PRECHECK(SetPortPenSize);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
PyMac_GetPoint, &penSize))
PyObject *_res = NULL;
CGrafPtr port;
SInt32 penMode;
+#ifndef SetPortPenMode
+ PyMac_PRECHECK(SetPortPenMode);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
GrafObj_Convert, &port,
&penMode))
PyObject *_res = NULL;
CGrafPtr port;
short pnLocHFrac;
+#ifndef SetPortFracHPenLocation
+ PyMac_PRECHECK(SetPortFracHPenLocation);
+#endif
if (!PyArg_ParseTuple(_args, "O&h",
GrafObj_Convert, &port,
&pnLocHFrac))
PyObject *_res = NULL;
PixMapHandle pixMap;
Rect bounds;
+#ifndef GetPixBounds
+ PyMac_PRECHECK(GetPixBounds);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &pixMap))
return NULL;
PyObject *_res = NULL;
short _rv;
PixMapHandle pixMap;
+#ifndef GetPixDepth
+ PyMac_PRECHECK(GetPixDepth);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &pixMap))
return NULL;
{
PyObject *_res = NULL;
long _rv;
+#ifndef GetQDGlobalsRandomSeed
+ PyMac_PRECHECK(GetQDGlobalsRandomSeed);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetQDGlobalsRandomSeed();
{
PyObject *_res = NULL;
BitMap screenBits;
+#ifndef GetQDGlobalsScreenBits
+ PyMac_PRECHECK(GetQDGlobalsScreenBits);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetQDGlobalsScreenBits(&screenBits);
{
PyObject *_res = NULL;
Cursor arrow__out__;
+#ifndef GetQDGlobalsArrow
+ PyMac_PRECHECK(GetQDGlobalsArrow);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetQDGlobalsArrow(&arrow__out__);
{
PyObject *_res = NULL;
Pattern dkGray__out__;
+#ifndef GetQDGlobalsDarkGray
+ PyMac_PRECHECK(GetQDGlobalsDarkGray);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetQDGlobalsDarkGray(&dkGray__out__);
{
PyObject *_res = NULL;
Pattern ltGray__out__;
+#ifndef GetQDGlobalsLightGray
+ PyMac_PRECHECK(GetQDGlobalsLightGray);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetQDGlobalsLightGray(<Gray__out__);
{
PyObject *_res = NULL;
Pattern gray__out__;
+#ifndef GetQDGlobalsGray
+ PyMac_PRECHECK(GetQDGlobalsGray);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetQDGlobalsGray(&gray__out__);
{
PyObject *_res = NULL;
Pattern black__out__;
+#ifndef GetQDGlobalsBlack
+ PyMac_PRECHECK(GetQDGlobalsBlack);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetQDGlobalsBlack(&black__out__);
{
PyObject *_res = NULL;
Pattern white__out__;
+#ifndef GetQDGlobalsWhite
+ PyMac_PRECHECK(GetQDGlobalsWhite);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetQDGlobalsWhite(&white__out__);
{
PyObject *_res = NULL;
CGrafPtr _rv;
+#ifndef GetQDGlobalsThePort
+ PyMac_PRECHECK(GetQDGlobalsThePort);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetQDGlobalsThePort();
{
PyObject *_res = NULL;
long randomSeed;
+#ifndef SetQDGlobalsRandomSeed
+ PyMac_PRECHECK(SetQDGlobalsRandomSeed);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&randomSeed))
return NULL;
PyObject *_res = NULL;
Cursor *arrow__in__;
int arrow__in_len__;
+#ifndef SetQDGlobalsArrow
+ PyMac_PRECHECK(SetQDGlobalsArrow);
+#endif
if (!PyArg_ParseTuple(_args, "s#",
(char **)&arrow__in__, &arrow__in_len__))
return NULL;
PyObject *_res = NULL;
RgnHandle region;
Rect bounds;
+#ifndef GetRegionBounds
+ PyMac_PRECHECK(GetRegionBounds);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, ®ion))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
RgnHandle region;
+#ifndef IsRegionRectangular
+ PyMac_PRECHECK(IsRegionRectangular);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, ®ion))
return NULL;
{
PyObject *_res = NULL;
CGrafPtr _rv;
+#ifndef CreateNewPort
+ PyMac_PRECHECK(CreateNewPort);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CreateNewPort();
{
PyObject *_res = NULL;
CGrafPtr port;
+#ifndef DisposePort
+ PyMac_PRECHECK(DisposePort);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
{
PyObject *_res = NULL;
OSErr err;
+#ifndef SetQDError
+ PyMac_PRECHECK(SetQDError);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&err))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
CGrafPtr port;
+#ifndef QDIsPortBuffered
+ PyMac_PRECHECK(QDIsPortBuffered);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
CGrafPtr port;
+#ifndef QDIsPortBufferDirty
+ PyMac_PRECHECK(QDIsPortBufferDirty);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
PyObject *_res = NULL;
CGrafPtr port;
RgnHandle region;
+#ifndef QDFlushPortBuffer
+ PyMac_PRECHECK(QDFlushPortBuffer);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
OptResObj_Convert, ®ion))
OSStatus _err;
CGrafPtr port;
RgnHandle rgn;
+#ifndef QDGetDirtyRegion
+ PyMac_PRECHECK(QDGetDirtyRegion);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
ResObj_Convert, &rgn))
OSStatus _err;
CGrafPtr port;
RgnHandle rgn;
+#ifndef QDSetDirtyRegion
+ PyMac_PRECHECK(QDSetDirtyRegion);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
ResObj_Convert, &rgn))
{
PyObject *_res = NULL;
SInt16 _rv;
+#ifndef LMGetScrVRes
+ PyMac_PRECHECK(LMGetScrVRes);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = LMGetScrVRes();
{
PyObject *_res = NULL;
SInt16 value;
+#ifndef LMSetScrVRes
+ PyMac_PRECHECK(LMSetScrVRes);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&value))
return NULL;
{
PyObject *_res = NULL;
SInt16 _rv;
+#ifndef LMGetScrHRes
+ PyMac_PRECHECK(LMGetScrHRes);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = LMGetScrHRes();
{
PyObject *_res = NULL;
SInt16 value;
+#ifndef LMSetScrHRes
+ PyMac_PRECHECK(LMSetScrHRes);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&value))
return NULL;
{
PyObject *_res = NULL;
GDHandle _rv;
+#ifndef LMGetMainDevice
+ PyMac_PRECHECK(LMGetMainDevice);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = LMGetMainDevice();
{
PyObject *_res = NULL;
GDHandle value;
+#ifndef LMSetMainDevice
+ PyMac_PRECHECK(LMSetMainDevice);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &value))
return NULL;
{
PyObject *_res = NULL;
GDHandle _rv;
+#ifndef LMGetDeviceList
+ PyMac_PRECHECK(LMGetDeviceList);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = LMGetDeviceList();
{
PyObject *_res = NULL;
GDHandle value;
+#ifndef LMSetDeviceList
+ PyMac_PRECHECK(LMSetDeviceList);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &value))
return NULL;
{
PyObject *_res = NULL;
Handle _rv;
+#ifndef LMGetQDColors
+ PyMac_PRECHECK(LMGetQDColors);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = LMGetQDColors();
{
PyObject *_res = NULL;
Handle value;
+#ifndef LMSetQDColors
+ PyMac_PRECHECK(LMSetQDColors);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &value))
return NULL;
{
PyObject *_res = NULL;
Handle _rv;
+#ifndef LMGetWidthListHand
+ PyMac_PRECHECK(LMGetWidthListHand);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = LMGetWidthListHand();
{
PyObject *_res = NULL;
Handle value;
+#ifndef LMSetWidthListHand
+ PyMac_PRECHECK(LMSetWidthListHand);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &value))
return NULL;
{
PyObject *_res = NULL;
UInt8 _rv;
+#ifndef LMGetHiliteMode
+ PyMac_PRECHECK(LMGetHiliteMode);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = LMGetHiliteMode();
{
PyObject *_res = NULL;
UInt8 value;
+#ifndef LMSetHiliteMode
+ PyMac_PRECHECK(LMSetHiliteMode);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&value))
return NULL;
{
PyObject *_res = NULL;
Handle _rv;
+#ifndef LMGetWidthTabHandle
+ PyMac_PRECHECK(LMGetWidthTabHandle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = LMGetWidthTabHandle();
{
PyObject *_res = NULL;
Handle value;
+#ifndef LMSetWidthTabHandle
+ PyMac_PRECHECK(LMSetWidthTabHandle);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &value))
return NULL;
{
PyObject *_res = NULL;
SInt32 _rv;
+#ifndef LMGetLastSPExtra
+ PyMac_PRECHECK(LMGetLastSPExtra);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = LMGetLastSPExtra();
{
PyObject *_res = NULL;
SInt32 value;
+#ifndef LMSetLastSPExtra
+ PyMac_PRECHECK(LMSetLastSPExtra);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&value))
return NULL;
{
PyObject *_res = NULL;
Handle _rv;
+#ifndef LMGetLastFOND
+ PyMac_PRECHECK(LMGetLastFOND);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = LMGetLastFOND();
{
PyObject *_res = NULL;
Handle value;
+#ifndef LMSetLastFOND
+ PyMac_PRECHECK(LMSetLastFOND);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &value))
return NULL;
{
PyObject *_res = NULL;
UInt8 _rv;
+#ifndef LMGetFractEnable
+ PyMac_PRECHECK(LMGetFractEnable);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = LMGetFractEnable();
{
PyObject *_res = NULL;
UInt8 value;
+#ifndef LMSetFractEnable
+ PyMac_PRECHECK(LMSetFractEnable);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&value))
return NULL;
{
PyObject *_res = NULL;
GDHandle _rv;
+#ifndef LMGetTheGDevice
+ PyMac_PRECHECK(LMGetTheGDevice);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = LMGetTheGDevice();
{
PyObject *_res = NULL;
GDHandle value;
+#ifndef LMSetTheGDevice
+ PyMac_PRECHECK(LMSetTheGDevice);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &value))
return NULL;
{
PyObject *_res = NULL;
RGBColor hiliteRGBValue;
+#ifndef LMGetHiliteRGB
+ PyMac_PRECHECK(LMGetHiliteRGB);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
LMGetHiliteRGB(&hiliteRGBValue);
{
PyObject *_res = NULL;
RGBColor hiliteRGBValue;
+#ifndef LMSetHiliteRGB
+ PyMac_PRECHECK(LMSetHiliteRGB);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
QdRGB_Convert, &hiliteRGBValue))
return NULL;
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef LMGetCursorNew
+ PyMac_PRECHECK(LMGetCursorNew);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = LMGetCursorNew();
{
PyObject *_res = NULL;
Boolean value;
+#ifndef LMSetCursorNew
+ PyMac_PRECHECK(LMSetCursorNew);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&value))
return NULL;
{
PyObject *_res = NULL;
short font;
+#ifndef TextFont
+ PyMac_PRECHECK(TextFont);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&font))
return NULL;
{
PyObject *_res = NULL;
StyleParameter face;
+#ifndef TextFace
+ PyMac_PRECHECK(TextFace);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&face))
return NULL;
{
PyObject *_res = NULL;
short mode;
+#ifndef TextMode
+ PyMac_PRECHECK(TextMode);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&mode))
return NULL;
{
PyObject *_res = NULL;
short size;
+#ifndef TextSize
+ PyMac_PRECHECK(TextSize);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&size))
return NULL;
{
PyObject *_res = NULL;
Fixed extra;
+#ifndef SpaceExtra
+ PyMac_PRECHECK(SpaceExtra);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetFixed, &extra))
return NULL;
{
PyObject *_res = NULL;
CharParameter ch;
+#ifndef DrawChar
+ PyMac_PRECHECK(DrawChar);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&ch))
return NULL;
{
PyObject *_res = NULL;
Str255 s;
+#ifndef DrawString
+ PyMac_PRECHECK(DrawString);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetStr255, s))
return NULL;
int textBuf__in_len__;
short firstByte;
short byteCount;
+#ifndef MacDrawText
+ PyMac_PRECHECK(MacDrawText);
+#endif
if (!PyArg_ParseTuple(_args, "s#hh",
&textBuf__in__, &textBuf__in_len__,
&firstByte,
PyObject *_res = NULL;
short _rv;
CharParameter ch;
+#ifndef CharWidth
+ PyMac_PRECHECK(CharWidth);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&ch))
return NULL;
PyObject *_res = NULL;
short _rv;
Str255 s;
+#ifndef StringWidth
+ PyMac_PRECHECK(StringWidth);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetStr255, s))
return NULL;
int textBuf__in_len__;
short firstByte;
short byteCount;
+#ifndef TextWidth
+ PyMac_PRECHECK(TextWidth);
+#endif
if (!PyArg_ParseTuple(_args, "s#hh",
&textBuf__in__, &textBuf__in_len__,
&firstByte,
{
PyObject *_res = NULL;
FontInfo info;
+#ifndef GetFontInfo
+ PyMac_PRECHECK(GetFontInfo);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetFontInfo(&info);
{
PyObject *_res = NULL;
Fixed extra;
+#ifndef CharExtra
+ PyMac_PRECHECK(CharExtra);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetFixed, &extra))
return NULL;
short width;
Str255 theString;
TruncCode truncWhere;
+#ifndef TruncString
+ PyMac_PRECHECK(TruncString);
+#endif
if (!PyArg_ParseTuple(_args, "hO&h",
&width,
PyMac_GetStr255, theString,
{
PyObject *_res = NULL;
GrafPtr thePort;
+#ifndef SetPort
+ PyMac_PRECHECK(SetPort);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &thePort))
return NULL;
PyObject *_res = NULL;
CursHandle _rv;
short cursorID;
+#ifndef GetCursor
+ PyMac_PRECHECK(GetCursor);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&cursorID))
return NULL;
PyObject *_res = NULL;
Cursor *crsr__in__;
int crsr__in_len__;
+#ifndef SetCursor
+ PyMac_PRECHECK(SetCursor);
+#endif
if (!PyArg_ParseTuple(_args, "s#",
(char **)&crsr__in__, &crsr__in_len__))
return NULL;
static PyObject *Qd_ShowCursor(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef ShowCursor
+ PyMac_PRECHECK(ShowCursor);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
ShowCursor();
PyObject *_res = NULL;
short h;
short v;
+#ifndef LineTo
+ PyMac_PRECHECK(LineTo);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&h,
&v))
short top;
short right;
short bottom;
+#ifndef SetRect
+ PyMac_PRECHECK(SetRect);
+#endif
if (!PyArg_ParseTuple(_args, "hhhh",
&left,
&top,
Rect r;
short dh;
short dv;
+#ifndef OffsetRect
+ PyMac_PRECHECK(OffsetRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
PyMac_GetRect, &r,
&dh,
Rect r;
short dh;
short dv;
+#ifndef InsetRect
+ PyMac_PRECHECK(InsetRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
PyMac_GetRect, &r,
&dh,
Rect src1;
Rect src2;
Rect dstRect;
+#ifndef UnionRect
+ PyMac_PRECHECK(UnionRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetRect, &src1,
PyMac_GetRect, &src2))
Boolean _rv;
Rect rect1;
Rect rect2;
+#ifndef EqualRect
+ PyMac_PRECHECK(EqualRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetRect, &rect1,
PyMac_GetRect, &rect2))
{
PyObject *_res = NULL;
Rect r;
+#ifndef FrameRect
+ PyMac_PRECHECK(FrameRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &r))
return NULL;
{
PyObject *_res = NULL;
Rect r;
+#ifndef InvertRect
+ PyMac_PRECHECK(InvertRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &r))
return NULL;
Rect r;
Pattern *pat__in__;
int pat__in_len__;
+#ifndef FillRect
+ PyMac_PRECHECK(FillRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&s#",
PyMac_GetRect, &r,
(char **)&pat__in__, &pat__in_len__))
PyObject *_res = NULL;
RgnHandle srcRgn;
RgnHandle dstRgn;
+#ifndef CopyRgn
+ PyMac_PRECHECK(CopyRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &srcRgn,
ResObj_Convert, &dstRgn))
short top;
short right;
short bottom;
+#ifndef SetRectRgn
+ PyMac_PRECHECK(SetRectRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&hhhh",
ResObj_Convert, &rgn,
&left,
RgnHandle rgn;
short dh;
short dv;
+#ifndef OffsetRgn
+ PyMac_PRECHECK(OffsetRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
ResObj_Convert, &rgn,
&dh,
RgnHandle srcRgnA;
RgnHandle srcRgnB;
RgnHandle dstRgn;
+#ifndef UnionRgn
+ PyMac_PRECHECK(UnionRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
ResObj_Convert, &srcRgnA,
ResObj_Convert, &srcRgnB,
RgnHandle srcRgnA;
RgnHandle srcRgnB;
RgnHandle dstRgn;
+#ifndef XorRgn
+ PyMac_PRECHECK(XorRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
ResObj_Convert, &srcRgnA,
ResObj_Convert, &srcRgnB,
Boolean _rv;
RgnHandle rgnA;
RgnHandle rgnB;
+#ifndef EqualRgn
+ PyMac_PRECHECK(EqualRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &rgnA,
ResObj_Convert, &rgnB))
{
PyObject *_res = NULL;
RgnHandle rgn;
+#ifndef FrameRgn
+ PyMac_PRECHECK(FrameRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &rgn))
return NULL;
{
PyObject *_res = NULL;
RgnHandle rgn;
+#ifndef PaintRgn
+ PyMac_PRECHECK(PaintRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &rgn))
return NULL;
{
PyObject *_res = NULL;
RgnHandle rgn;
+#ifndef InvertRgn
+ PyMac_PRECHECK(InvertRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &rgn))
return NULL;
RgnHandle rgn;
Pattern *pat__in__;
int pat__in_len__;
+#ifndef FillRgn
+ PyMac_PRECHECK(FillRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&s#",
ResObj_Convert, &rgn,
(char **)&pat__in__, &pat__in_len__))
Boolean _rv;
short h;
short v;
+#ifndef GetPixel
+ PyMac_PRECHECK(GetPixel);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&h,
&v))
Boolean _rv;
Point pt;
Rect r;
+#ifndef PtInRect
+ PyMac_PRECHECK(PtInRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetPoint, &pt,
PyMac_GetRect, &r))
int textBuf__in_len__;
short firstByte;
short byteCount;
+#ifndef DrawText
+ PyMac_PRECHECK(DrawText);
+#endif
if (!PyArg_ParseTuple(_args, "s#hh",
&textBuf__in__, &textBuf__in_len__,
&firstByte,
{
PyObject *_res = NULL;
GDHandle _rv;
+#ifndef GetGWorldDevice
+ PyMac_PRECHECK(GetGWorldDevice);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetGWorldDevice(_self->ob_itself);
{
PyObject *_res = NULL;
PixMapHandle _rv;
+#ifndef GetGWorldPixMap
+ PyMac_PRECHECK(GetGWorldPixMap);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetGWorldPixMap(_self->ob_itself);
{
PyObject *_res = NULL;
GrafPtr _rv;
+#ifndef as_GrafPtr
+ PyMac_PRECHECK(as_GrafPtr);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = as_GrafPtr(_self->ob_itself);
CTabHandle cTable;
GDHandle aGDevice;
GWorldFlags flags;
+#ifndef NewGWorld
+ PyMac_PRECHECK(NewGWorld);
+#endif
if (!PyArg_ParseTuple(_args, "hO&O&O&l",
&PixelDepth,
PyMac_GetRect, &boundsRect,
PyObject *_res = NULL;
Boolean _rv;
PixMapHandle pm;
+#ifndef LockPixels
+ PyMac_PRECHECK(LockPixels);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &pm))
return NULL;
{
PyObject *_res = NULL;
PixMapHandle pm;
+#ifndef UnlockPixels
+ PyMac_PRECHECK(UnlockPixels);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &pm))
return NULL;
CTabHandle cTable;
GDHandle aGDevice;
GWorldFlags flags;
+#ifndef UpdateGWorld
+ PyMac_PRECHECK(UpdateGWorld);
+#endif
if (!PyArg_ParseTuple(_args, "hO&O&O&l",
&pixelDepth,
PyMac_GetRect, &boundsRect,
PyObject *_res = NULL;
CGrafPtr port;
GDHandle gdh;
+#ifndef GetGWorld
+ PyMac_PRECHECK(GetGWorld);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetGWorld(&port,
PyObject *_res = NULL;
CGrafPtr port;
GDHandle gdh;
+#ifndef SetGWorld
+ PyMac_PRECHECK(SetGWorld);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
OptResObj_Convert, &gdh))
{
PyObject *_res = NULL;
CTabHandle ctab;
+#ifndef CTabChanged
+ PyMac_PRECHECK(CTabChanged);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
OptResObj_Convert, &ctab))
return NULL;
{
PyObject *_res = NULL;
PixPatHandle ppat;
+#ifndef PixPatChanged
+ PyMac_PRECHECK(PixPatChanged);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &ppat))
return NULL;
{
PyObject *_res = NULL;
GrafPtr port;
+#ifndef PortChanged
+ PyMac_PRECHECK(PortChanged);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
{
PyObject *_res = NULL;
GDHandle gdh;
+#ifndef GDeviceChanged
+ PyMac_PRECHECK(GDeviceChanged);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
OptResObj_Convert, &gdh))
return NULL;
{
PyObject *_res = NULL;
PixMapHandle pm;
+#ifndef AllowPurgePixels
+ PyMac_PRECHECK(AllowPurgePixels);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &pm))
return NULL;
{
PyObject *_res = NULL;
PixMapHandle pm;
+#ifndef NoPurgePixels
+ PyMac_PRECHECK(NoPurgePixels);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &pm))
return NULL;
PyObject *_res = NULL;
GWorldFlags _rv;
PixMapHandle pm;
+#ifndef GetPixelsState
+ PyMac_PRECHECK(GetPixelsState);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &pm))
return NULL;
PyObject *_res = NULL;
PixMapHandle pm;
GWorldFlags state;
+#ifndef SetPixelsState
+ PyMac_PRECHECK(SetPixelsState);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
ResObj_Convert, &pm,
&state))
PyObject *_res = NULL;
long _rv;
PixMapHandle pm;
+#ifndef GetPixRowBytes
+ PyMac_PRECHECK(GetPixRowBytes);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &pm))
return NULL;
Boolean purgeable;
GDHandle gdh;
PixMapHandle offscreenPixMap;
+#ifndef NewScreenBuffer
+ PyMac_PRECHECK(NewScreenBuffer);
+#endif
if (!PyArg_ParseTuple(_args, "O&b",
PyMac_GetRect, &globalRect,
&purgeable))
{
PyObject *_res = NULL;
PixMapHandle offscreenPixMap;
+#ifndef DisposeScreenBuffer
+ PyMac_PRECHECK(DisposeScreenBuffer);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &offscreenPixMap))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
GrafPtr port;
+#ifndef QDDone
+ PyMac_PRECHECK(QDDone);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
{
PyObject *_res = NULL;
long _rv;
+#ifndef OffscreenVersion
+ PyMac_PRECHECK(OffscreenVersion);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = OffscreenVersion();
Boolean purgeable;
GDHandle gdh;
PixMapHandle offscreenPixMap;
+#ifndef NewTempScreenBuffer
+ PyMac_PRECHECK(NewTempScreenBuffer);
+#endif
if (!PyArg_ParseTuple(_args, "O&b",
PyMac_GetRect, &globalRect,
&purgeable))
PyObject *_res = NULL;
Boolean _rv;
PixMapHandle pmHandle;
+#ifndef PixMap32Bit
+ PyMac_PRECHECK(PixMap32Bit);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &pmHandle))
return NULL;
Movie theMovie;
WindowPtr movieWindow;
Point where;
+#ifndef MCSetMovie
+ PyMac_PRECHECK(MCSetMovie);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
MovieObj_Convert, &theMovie,
WinObj_Convert, &movieWindow,
PyObject *_res = NULL;
Movie _rv;
short index;
+#ifndef MCGetIndMovie
+ PyMac_PRECHECK(MCGetIndMovie);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&index))
return NULL;
{
PyObject *_res = NULL;
ComponentResult _rv;
+#ifndef MCRemoveAllMovies
+ PyMac_PRECHECK(MCRemoveAllMovies);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MCRemoveAllMovies(_self->ob_itself);
PyObject *_res = NULL;
ComponentResult _rv;
Movie m;
+#ifndef MCRemoveAMovie
+ PyMac_PRECHECK(MCRemoveAMovie);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
MovieObj_Convert, &m))
return NULL;
{
PyObject *_res = NULL;
ComponentResult _rv;
+#ifndef MCRemoveMovie
+ PyMac_PRECHECK(MCRemoveMovie);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MCRemoveMovie(_self->ob_itself);
PyObject *_res = NULL;
ComponentResult _rv;
EventRecord e;
+#ifndef MCIsPlayerEvent
+ PyMac_PRECHECK(MCIsPlayerEvent);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetEventRecord, &e))
return NULL;
ComponentResult _rv;
short action;
void * params;
+#ifndef MCDoAction
+ PyMac_PRECHECK(MCDoAction);
+#endif
if (!PyArg_ParseTuple(_args, "hs",
&action,
¶ms))
PyObject *_res = NULL;
ComponentResult _rv;
Boolean attach;
+#ifndef MCSetControllerAttached
+ PyMac_PRECHECK(MCSetControllerAttached);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&attach))
return NULL;
{
PyObject *_res = NULL;
ComponentResult _rv;
+#ifndef MCIsControllerAttached
+ PyMac_PRECHECK(MCIsControllerAttached);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MCIsControllerAttached(_self->ob_itself);
PyObject *_res = NULL;
ComponentResult _rv;
CGrafPtr gp;
+#ifndef MCSetControllerPort
+ PyMac_PRECHECK(MCSetControllerPort);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &gp))
return NULL;
{
PyObject *_res = NULL;
CGrafPtr _rv;
+#ifndef MCGetControllerPort
+ PyMac_PRECHECK(MCGetControllerPort);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MCGetControllerPort(_self->ob_itself);
PyObject *_res = NULL;
ComponentResult _rv;
Boolean visible;
+#ifndef MCSetVisible
+ PyMac_PRECHECK(MCSetVisible);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&visible))
return NULL;
{
PyObject *_res = NULL;
ComponentResult _rv;
+#ifndef MCGetVisible
+ PyMac_PRECHECK(MCGetVisible);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MCGetVisible(_self->ob_itself);
PyObject *_res = NULL;
ComponentResult _rv;
Rect bounds;
+#ifndef MCGetControllerBoundsRect
+ PyMac_PRECHECK(MCGetControllerBoundsRect);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MCGetControllerBoundsRect(_self->ob_itself,
PyObject *_res = NULL;
ComponentResult _rv;
Rect bounds;
+#ifndef MCSetControllerBoundsRect
+ PyMac_PRECHECK(MCSetControllerBoundsRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &bounds))
return NULL;
{
PyObject *_res = NULL;
RgnHandle _rv;
+#ifndef MCGetControllerBoundsRgn
+ PyMac_PRECHECK(MCGetControllerBoundsRgn);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MCGetControllerBoundsRgn(_self->ob_itself);
PyObject *_res = NULL;
RgnHandle _rv;
WindowPtr w;
+#ifndef MCGetWindowRgn
+ PyMac_PRECHECK(MCGetWindowRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
WinObj_Convert, &w))
return NULL;
PyObject *_res = NULL;
ComponentResult _rv;
Movie m;
+#ifndef MCMovieChanged
+ PyMac_PRECHECK(MCMovieChanged);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
MovieObj_Convert, &m))
return NULL;
PyObject *_res = NULL;
ComponentResult _rv;
TimeValue duration;
+#ifndef MCSetDuration
+ PyMac_PRECHECK(MCSetDuration);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&duration))
return NULL;
PyObject *_res = NULL;
TimeValue _rv;
TimeScale scale;
+#ifndef MCGetCurrentTime
+ PyMac_PRECHECK(MCGetCurrentTime);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MCGetCurrentTime(_self->ob_itself,
Movie theMovie;
WindowPtr w;
Point where;
+#ifndef MCNewAttachedController
+ PyMac_PRECHECK(MCNewAttachedController);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
MovieObj_Convert, &theMovie,
WinObj_Convert, &w,
PyObject *_res = NULL;
ComponentResult _rv;
WindowPtr w;
+#ifndef MCDraw
+ PyMac_PRECHECK(MCDraw);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
WinObj_Convert, &w))
return NULL;
ComponentResult _rv;
WindowPtr w;
Boolean activate;
+#ifndef MCActivate
+ PyMac_PRECHECK(MCActivate);
+#endif
if (!PyArg_ParseTuple(_args, "O&b",
WinObj_Convert, &w,
&activate))
{
PyObject *_res = NULL;
ComponentResult _rv;
+#ifndef MCIdle
+ PyMac_PRECHECK(MCIdle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MCIdle(_self->ob_itself);
ComponentResult _rv;
SInt8 key;
long modifiers;
+#ifndef MCKey
+ PyMac_PRECHECK(MCKey);
+#endif
if (!PyArg_ParseTuple(_args, "bl",
&key,
&modifiers))
Point where;
long when;
long modifiers;
+#ifndef MCClick
+ PyMac_PRECHECK(MCClick);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&ll",
WinObj_Convert, &w,
PyMac_GetPoint, &where,
PyObject *_res = NULL;
ComponentResult _rv;
Boolean enabled;
+#ifndef MCEnableEditing
+ PyMac_PRECHECK(MCEnableEditing);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&enabled))
return NULL;
{
PyObject *_res = NULL;
long _rv;
+#ifndef MCIsEditingEnabled
+ PyMac_PRECHECK(MCIsEditingEnabled);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MCIsEditingEnabled(_self->ob_itself);
{
PyObject *_res = NULL;
Movie _rv;
+#ifndef MCCopy
+ PyMac_PRECHECK(MCCopy);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MCCopy(_self->ob_itself);
{
PyObject *_res = NULL;
Movie _rv;
+#ifndef MCCut
+ PyMac_PRECHECK(MCCut);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MCCut(_self->ob_itself);
PyObject *_res = NULL;
ComponentResult _rv;
Movie srcMovie;
+#ifndef MCPaste
+ PyMac_PRECHECK(MCPaste);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
MovieObj_Convert, &srcMovie))
return NULL;
{
PyObject *_res = NULL;
ComponentResult _rv;
+#ifndef MCClear
+ PyMac_PRECHECK(MCClear);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MCClear(_self->ob_itself);
{
PyObject *_res = NULL;
ComponentResult _rv;
+#ifndef MCUndo
+ PyMac_PRECHECK(MCUndo);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MCUndo(_self->ob_itself);
Rect movieRect;
Rect controllerRect;
long someFlags;
+#ifndef MCPositionController
+ PyMac_PRECHECK(MCPositionController);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&l",
PyMac_GetRect, &movieRect,
PyMac_GetRect, &controllerRect,
PyObject *_res = NULL;
ComponentResult _rv;
long someFlags;
+#ifndef MCGetControllerInfo
+ PyMac_PRECHECK(MCGetControllerInfo);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MCGetControllerInfo(_self->ob_itself,
ComponentResult _rv;
RgnHandle theClip;
RgnHandle movieClip;
+#ifndef MCSetClip
+ PyMac_PRECHECK(MCSetClip);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &theClip,
ResObj_Convert, &movieClip))
ComponentResult _rv;
RgnHandle theClip;
RgnHandle movieClip;
+#ifndef MCGetClip
+ PyMac_PRECHECK(MCGetClip);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MCGetClip(_self->ob_itself,
ComponentResult _rv;
RgnHandle movieRgn;
RgnHandle badgeRgn;
+#ifndef MCDrawBadge
+ PyMac_PRECHECK(MCDrawBadge);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &movieRgn))
return NULL;
ComponentResult _rv;
long modifiers;
MenuHandle mh;
+#ifndef MCSetUpEditMenu
+ PyMac_PRECHECK(MCSetUpEditMenu);
+#endif
if (!PyArg_ParseTuple(_args, "lO&",
&modifiers,
MenuObj_Convert, &mh))
long modifiers;
short item;
Str255 aString;
+#ifndef MCGetMenuString
+ PyMac_PRECHECK(MCGetMenuString);
+#endif
if (!PyArg_ParseTuple(_args, "lhO&",
&modifiers,
&item,
ComponentResult _rv;
Point thePt;
Boolean inController;
+#ifndef MCPtInController
+ PyMac_PRECHECK(MCPtInController);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetPoint, &thePt))
return NULL;
ComponentResult _rv;
WindowPtr w;
RgnHandle invalidRgn;
+#ifndef MCInvalidate
+ PyMac_PRECHECK(MCInvalidate);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
WinObj_Convert, &w,
ResObj_Convert, &invalidRgn))
WindowPtr w;
Point where;
long modifiers;
+#ifndef MCAdjustCursor
+ PyMac_PRECHECK(MCAdjustCursor);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&l",
WinObj_Convert, &w,
PyMac_GetPoint, &where,
ComponentResult _rv;
MCInterfaceElement whichElement;
void * element;
+#ifndef MCGetInterfaceElement
+ PyMac_PRECHECK(MCGetInterfaceElement);
+#endif
if (!PyArg_ParseTuple(_args, "ls",
&whichElement,
&element))
ComponentResult _rv;
Movie srcMovie;
Boolean scaled;
+#ifndef MCAddMovieSegment
+ PyMac_PRECHECK(MCAddMovieSegment);
+#endif
if (!PyArg_ParseTuple(_args, "O&b",
MovieObj_Convert, &srcMovie,
&scaled))
{
PyObject *_res = NULL;
ComponentResult _rv;
+#ifndef MCTrimMovieSegment
+ PyMac_PRECHECK(MCTrimMovieSegment);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MCTrimMovieSegment(_self->ob_itself);
static PyObject *TimeBaseObj_DisposeTimeBase(TimeBaseObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef DisposeTimeBase
+ PyMac_PRECHECK(DisposeTimeBase);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
DisposeTimeBase(_self->ob_itself);
TimeValue _rv;
TimeScale s;
TimeRecord tr;
+#ifndef GetTimeBaseTime
+ PyMac_PRECHECK(GetTimeBaseTime);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&s))
return NULL;
{
PyObject *_res = NULL;
TimeRecord tr;
+#ifndef SetTimeBaseTime
+ PyMac_PRECHECK(SetTimeBaseTime);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
QtTimeRecord_Convert, &tr))
return NULL;
PyObject *_res = NULL;
TimeValue t;
TimeScale s;
+#ifndef SetTimeBaseValue
+ PyMac_PRECHECK(SetTimeBaseValue);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&t,
&s))
{
PyObject *_res = NULL;
Fixed _rv;
+#ifndef GetTimeBaseRate
+ PyMac_PRECHECK(GetTimeBaseRate);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTimeBaseRate(_self->ob_itself);
{
PyObject *_res = NULL;
Fixed r;
+#ifndef SetTimeBaseRate
+ PyMac_PRECHECK(SetTimeBaseRate);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetFixed, &r))
return NULL;
TimeValue _rv;
TimeScale s;
TimeRecord tr;
+#ifndef GetTimeBaseStartTime
+ PyMac_PRECHECK(GetTimeBaseStartTime);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&s))
return NULL;
{
PyObject *_res = NULL;
TimeRecord tr;
+#ifndef SetTimeBaseStartTime
+ PyMac_PRECHECK(SetTimeBaseStartTime);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
QtTimeRecord_Convert, &tr))
return NULL;
TimeValue _rv;
TimeScale s;
TimeRecord tr;
+#ifndef GetTimeBaseStopTime
+ PyMac_PRECHECK(GetTimeBaseStopTime);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&s))
return NULL;
{
PyObject *_res = NULL;
TimeRecord tr;
+#ifndef SetTimeBaseStopTime
+ PyMac_PRECHECK(SetTimeBaseStopTime);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
QtTimeRecord_Convert, &tr))
return NULL;
{
PyObject *_res = NULL;
long _rv;
+#ifndef GetTimeBaseFlags
+ PyMac_PRECHECK(GetTimeBaseFlags);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTimeBaseFlags(_self->ob_itself);
{
PyObject *_res = NULL;
long timeBaseFlags;
+#ifndef SetTimeBaseFlags
+ PyMac_PRECHECK(SetTimeBaseFlags);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&timeBaseFlags))
return NULL;
PyObject *_res = NULL;
TimeBase master;
TimeRecord slaveZero;
+#ifndef SetTimeBaseMasterTimeBase
+ PyMac_PRECHECK(SetTimeBaseMasterTimeBase);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
TimeBaseObj_Convert, &master,
QtTimeRecord_Convert, &slaveZero))
{
PyObject *_res = NULL;
TimeBase _rv;
+#ifndef GetTimeBaseMasterTimeBase
+ PyMac_PRECHECK(GetTimeBaseMasterTimeBase);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTimeBaseMasterTimeBase(_self->ob_itself);
PyObject *_res = NULL;
Component clockMeister;
TimeRecord slaveZero;
+#ifndef SetTimeBaseMasterClock
+ PyMac_PRECHECK(SetTimeBaseMasterClock);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
CmpObj_Convert, &clockMeister,
QtTimeRecord_Convert, &slaveZero))
{
PyObject *_res = NULL;
ComponentInstance _rv;
+#ifndef GetTimeBaseMasterClock
+ PyMac_PRECHECK(GetTimeBaseMasterClock);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTimeBaseMasterClock(_self->ob_itself);
PyObject *_res = NULL;
long _rv;
TimeRecord unpinnedTime;
+#ifndef GetTimeBaseStatus
+ PyMac_PRECHECK(GetTimeBaseStatus);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTimeBaseStatus(_self->ob_itself,
{
PyObject *_res = NULL;
TimeRecord zero;
+#ifndef SetTimeBaseZero
+ PyMac_PRECHECK(SetTimeBaseZero);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
QtTimeRecord_Convert, &zero))
return NULL;
{
PyObject *_res = NULL;
Fixed _rv;
+#ifndef GetTimeBaseEffectiveRate
+ PyMac_PRECHECK(GetTimeBaseEffectiveRate);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTimeBaseEffectiveRate(_self->ob_itself);
Handle data;
OSType udType;
long index;
+#ifndef GetUserData
+ PyMac_PRECHECK(GetUserData);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&l",
ResObj_Convert, &data,
PyMac_GetOSType, &udType,
OSErr _err;
Handle data;
OSType udType;
+#ifndef AddUserData
+ PyMac_PRECHECK(AddUserData);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &data,
PyMac_GetOSType, &udType))
OSErr _err;
OSType udType;
long index;
+#ifndef RemoveUserData
+ PyMac_PRECHECK(RemoveUserData);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetOSType, &udType,
&index))
PyObject *_res = NULL;
short _rv;
OSType udType;
+#ifndef CountUserDataType
+ PyMac_PRECHECK(CountUserDataType);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetOSType, &udType))
return NULL;
PyObject *_res = NULL;
long _rv;
OSType udType;
+#ifndef GetNextUserDataType
+ PyMac_PRECHECK(GetNextUserDataType);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetOSType, &udType))
return NULL;
OSType udType;
long index;
short itlRegionTag;
+#ifndef AddUserDataText
+ PyMac_PRECHECK(AddUserDataText);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&lh",
ResObj_Convert, &data,
PyMac_GetOSType, &udType,
OSType udType;
long index;
short itlRegionTag;
+#ifndef GetUserDataText
+ PyMac_PRECHECK(GetUserDataText);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&lh",
ResObj_Convert, &data,
PyMac_GetOSType, &udType,
OSType udType;
long index;
short itlRegionTag;
+#ifndef RemoveUserDataText
+ PyMac_PRECHECK(RemoveUserDataText);
+#endif
if (!PyArg_ParseTuple(_args, "O&lh",
PyMac_GetOSType, &udType,
&index,
PyObject *_res = NULL;
OSErr _err;
Handle h;
+#ifndef PutUserDataIntoHandle
+ PyMac_PRECHECK(PutUserDataIntoHandle);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &h))
return NULL;
TimeValue time;
TimeValue duration;
long flags;
+#ifndef LoadMediaIntoRam
+ PyMac_PRECHECK(LoadMediaIntoRam);
+#endif
if (!PyArg_ParseTuple(_args, "lll",
&time,
&duration,
{
PyObject *_res = NULL;
Track _rv;
+#ifndef GetMediaTrack
+ PyMac_PRECHECK(GetMediaTrack);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMediaTrack(_self->ob_itself);
{
PyObject *_res = NULL;
unsigned long _rv;
+#ifndef GetMediaCreationTime
+ PyMac_PRECHECK(GetMediaCreationTime);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMediaCreationTime(_self->ob_itself);
{
PyObject *_res = NULL;
unsigned long _rv;
+#ifndef GetMediaModificationTime
+ PyMac_PRECHECK(GetMediaModificationTime);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMediaModificationTime(_self->ob_itself);
{
PyObject *_res = NULL;
TimeScale _rv;
+#ifndef GetMediaTimeScale
+ PyMac_PRECHECK(GetMediaTimeScale);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMediaTimeScale(_self->ob_itself);
{
PyObject *_res = NULL;
TimeScale timeScale;
+#ifndef SetMediaTimeScale
+ PyMac_PRECHECK(SetMediaTimeScale);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&timeScale))
return NULL;
{
PyObject *_res = NULL;
TimeValue _rv;
+#ifndef GetMediaDuration
+ PyMac_PRECHECK(GetMediaDuration);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMediaDuration(_self->ob_itself);
{
PyObject *_res = NULL;
short _rv;
+#ifndef GetMediaLanguage
+ PyMac_PRECHECK(GetMediaLanguage);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMediaLanguage(_self->ob_itself);
{
PyObject *_res = NULL;
short language;
+#ifndef SetMediaLanguage
+ PyMac_PRECHECK(SetMediaLanguage);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&language))
return NULL;
{
PyObject *_res = NULL;
short _rv;
+#ifndef GetMediaQuality
+ PyMac_PRECHECK(GetMediaQuality);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMediaQuality(_self->ob_itself);
{
PyObject *_res = NULL;
short quality;
+#ifndef SetMediaQuality
+ PyMac_PRECHECK(SetMediaQuality);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&quality))
return NULL;
OSType mediaType;
Str255 creatorName;
OSType creatorManufacturer;
+#ifndef GetMediaHandlerDescription
+ PyMac_PRECHECK(GetMediaHandlerDescription);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetStr255, creatorName))
return NULL;
{
PyObject *_res = NULL;
UserData _rv;
+#ifndef GetMediaUserData
+ PyMac_PRECHECK(GetMediaUserData);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMediaUserData(_self->ob_itself);
{
PyObject *_res = NULL;
MediaHandler _rv;
+#ifndef GetMediaHandler
+ PyMac_PRECHECK(GetMediaHandler);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMediaHandler(_self->ob_itself);
PyObject *_res = NULL;
OSErr _err;
MediaHandlerComponent mH;
+#ifndef SetMediaHandler
+ PyMac_PRECHECK(SetMediaHandler);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CmpObj_Convert, &mH))
return NULL;
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef BeginMediaEdits
+ PyMac_PRECHECK(BeginMediaEdits);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = BeginMediaEdits(_self->ob_itself);
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef EndMediaEdits
+ PyMac_PRECHECK(EndMediaEdits);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = EndMediaEdits(_self->ob_itself);
PyObject *_res = NULL;
OSErr _err;
short index;
+#ifndef SetMediaDefaultDataRefIndex
+ PyMac_PRECHECK(SetMediaDefaultDataRefIndex);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&index))
return NULL;
OSType dhType;
Str255 creatorName;
OSType creatorManufacturer;
+#ifndef GetMediaDataHandlerDescription
+ PyMac_PRECHECK(GetMediaDataHandlerDescription);
+#endif
if (!PyArg_ParseTuple(_args, "hO&",
&index,
PyMac_GetStr255, creatorName))
PyObject *_res = NULL;
DataHandler _rv;
short index;
+#ifndef GetMediaDataHandler
+ PyMac_PRECHECK(GetMediaDataHandler);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&index))
return NULL;
OSErr _err;
short index;
DataHandlerComponent dataHandler;
+#ifndef SetMediaDataHandler
+ PyMac_PRECHECK(SetMediaDataHandler);
+#endif
if (!PyArg_ParseTuple(_args, "hO&",
&index,
CmpObj_Convert, &dataHandler))
{
PyObject *_res = NULL;
long _rv;
+#ifndef GetMediaSampleDescriptionCount
+ PyMac_PRECHECK(GetMediaSampleDescriptionCount);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMediaSampleDescriptionCount(_self->ob_itself);
PyObject *_res = NULL;
long index;
SampleDescriptionHandle descH;
+#ifndef GetMediaSampleDescription
+ PyMac_PRECHECK(GetMediaSampleDescription);
+#endif
if (!PyArg_ParseTuple(_args, "lO&",
&index,
ResObj_Convert, &descH))
OSErr _err;
long index;
SampleDescriptionHandle descH;
+#ifndef SetMediaSampleDescription
+ PyMac_PRECHECK(SetMediaSampleDescription);
+#endif
if (!PyArg_ParseTuple(_args, "lO&",
&index,
ResObj_Convert, &descH))
{
PyObject *_res = NULL;
long _rv;
+#ifndef GetMediaSampleCount
+ PyMac_PRECHECK(GetMediaSampleCount);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMediaSampleCount(_self->ob_itself);
{
PyObject *_res = NULL;
long _rv;
+#ifndef GetMediaSyncSampleCount
+ PyMac_PRECHECK(GetMediaSyncSampleCount);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMediaSyncSampleCount(_self->ob_itself);
long logicalSampleNum;
TimeValue sampleTime;
TimeValue sampleDuration;
+#ifndef SampleNumToMediaTime
+ PyMac_PRECHECK(SampleNumToMediaTime);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&logicalSampleNum))
return NULL;
long sampleNum;
TimeValue sampleTime;
TimeValue sampleDuration;
+#ifndef MediaTimeToSampleNum
+ PyMac_PRECHECK(MediaTimeToSampleNum);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&time))
return NULL;
long numberOfSamples;
short sampleFlags;
TimeValue sampleTime;
+#ifndef AddMediaSample
+ PyMac_PRECHECK(AddMediaSample);
+#endif
if (!PyArg_ParseTuple(_args, "O&lllO&lh",
ResObj_Convert, &dataIn,
&inOffset,
long numberOfSamples;
short sampleFlags;
TimeValue sampleTime;
+#ifndef AddMediaSampleReference
+ PyMac_PRECHECK(AddMediaSampleReference);
+#endif
if (!PyArg_ParseTuple(_args, "lllO&lh",
&dataOffset,
&size,
long maxNumberOfSamples;
long numberOfSamples;
short sampleFlags;
+#ifndef GetMediaSample
+ PyMac_PRECHECK(GetMediaSample);
+#endif
if (!PyArg_ParseTuple(_args, "O&llO&l",
ResObj_Convert, &dataOut,
&maxSizeToGrow,
long maxNumberOfSamples;
long numberOfSamples;
short sampleFlags;
+#ifndef GetMediaSampleReference
+ PyMac_PRECHECK(GetMediaSampleReference);
+#endif
if (!PyArg_ParseTuple(_args, "lO&l",
&time,
ResObj_Convert, &sampleDescriptionH,
PyObject *_res = NULL;
OSErr _err;
long maxChunkSize;
+#ifndef SetMediaPreferredChunkSize
+ PyMac_PRECHECK(SetMediaPreferredChunkSize);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&maxChunkSize))
return NULL;
PyObject *_res = NULL;
OSErr _err;
long maxChunkSize;
+#ifndef GetMediaPreferredChunkSize
+ PyMac_PRECHECK(GetMediaPreferredChunkSize);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetMediaPreferredChunkSize(_self->ob_itself,
OSErr _err;
long frameDiffSampleNum;
long syncSampleNum;
+#ifndef SetMediaShadowSync
+ PyMac_PRECHECK(SetMediaShadowSync);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&frameDiffSampleNum,
&syncSampleNum))
OSErr _err;
long frameDiffSampleNum;
long syncSampleNum;
+#ifndef GetMediaShadowSync
+ PyMac_PRECHECK(GetMediaShadowSync);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&frameDiffSampleNum))
return NULL;
long _rv;
TimeValue startTime;
TimeValue duration;
+#ifndef GetMediaDataSize
+ PyMac_PRECHECK(GetMediaDataSize);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&startTime,
&duration))
TimeValue startTime;
TimeValue duration;
wide dataSize;
+#ifndef GetMediaDataSize64
+ PyMac_PRECHECK(GetMediaDataSize64);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&startTime,
&duration))
Fixed rate;
TimeValue interestingTime;
TimeValue interestingDuration;
+#ifndef GetMediaNextInterestingTime
+ PyMac_PRECHECK(GetMediaNextInterestingTime);
+#endif
if (!PyArg_ParseTuple(_args, "hlO&",
&interestingTimeFlags,
&time,
Handle dataRef;
OSType dataRefType;
long dataRefAttributes;
+#ifndef GetMediaDataRef
+ PyMac_PRECHECK(GetMediaDataRef);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&index))
return NULL;
short index;
Handle dataRef;
OSType dataRefType;
+#ifndef SetMediaDataRef
+ PyMac_PRECHECK(SetMediaDataRef);
+#endif
if (!PyArg_ParseTuple(_args, "hO&O&",
&index,
ResObj_Convert, &dataRef,
OSErr _err;
short index;
long dataRefAttributes;
+#ifndef SetMediaDataRefAttributes
+ PyMac_PRECHECK(SetMediaDataRefAttributes);
+#endif
if (!PyArg_ParseTuple(_args, "hl",
&index,
&dataRefAttributes))
short index;
Handle dataRef;
OSType dataRefType;
+#ifndef AddMediaDataRef
+ PyMac_PRECHECK(AddMediaDataRef);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &dataRef,
PyMac_GetOSType, &dataRefType))
PyObject *_res = NULL;
OSErr _err;
short count;
+#ifndef GetMediaDataRefCount
+ PyMac_PRECHECK(GetMediaDataRefCount);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetMediaDataRefCount(_self->ob_itself,
PyObject *_res = NULL;
long flags;
long flagsMask;
+#ifndef SetMediaPlayHints
+ PyMac_PRECHECK(SetMediaPlayHints);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&flags,
&flagsMask))
{
PyObject *_res = NULL;
long flags;
+#ifndef GetMediaPlayHints
+ PyMac_PRECHECK(GetMediaPlayHints);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetMediaPlayHints(_self->ob_itself,
TimeValue time;
Fixed rate;
TimeValue interestingTime;
+#ifndef GetMediaNextInterestingTimeOnly
+ PyMac_PRECHECK(GetMediaNextInterestingTimeOnly);
+#endif
if (!PyArg_ParseTuple(_args, "hlO&",
&interestingTimeFlags,
&time,
TimeValue time;
TimeValue duration;
long flags;
+#ifndef LoadTrackIntoRam
+ PyMac_PRECHECK(LoadTrackIntoRam);
+#endif
if (!PyArg_ParseTuple(_args, "lll",
&time,
&duration,
PyObject *_res = NULL;
PicHandle _rv;
TimeValue time;
+#ifndef GetTrackPict
+ PyMac_PRECHECK(GetTrackPict);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&time))
return NULL;
{
PyObject *_res = NULL;
RgnHandle _rv;
+#ifndef GetTrackClipRgn
+ PyMac_PRECHECK(GetTrackClipRgn);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackClipRgn(_self->ob_itself);
{
PyObject *_res = NULL;
RgnHandle theClip;
+#ifndef SetTrackClipRgn
+ PyMac_PRECHECK(SetTrackClipRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &theClip))
return NULL;
{
PyObject *_res = NULL;
RgnHandle _rv;
+#ifndef GetTrackDisplayBoundsRgn
+ PyMac_PRECHECK(GetTrackDisplayBoundsRgn);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackDisplayBoundsRgn(_self->ob_itself);
{
PyObject *_res = NULL;
RgnHandle _rv;
+#ifndef GetTrackMovieBoundsRgn
+ PyMac_PRECHECK(GetTrackMovieBoundsRgn);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackMovieBoundsRgn(_self->ob_itself);
{
PyObject *_res = NULL;
RgnHandle _rv;
+#ifndef GetTrackBoundsRgn
+ PyMac_PRECHECK(GetTrackBoundsRgn);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackBoundsRgn(_self->ob_itself);
{
PyObject *_res = NULL;
PixMapHandle _rv;
+#ifndef GetTrackMatte
+ PyMac_PRECHECK(GetTrackMatte);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackMatte(_self->ob_itself);
{
PyObject *_res = NULL;
PixMapHandle theMatte;
+#ifndef SetTrackMatte
+ PyMac_PRECHECK(SetTrackMatte);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &theMatte))
return NULL;
{
PyObject *_res = NULL;
long _rv;
+#ifndef GetTrackID
+ PyMac_PRECHECK(GetTrackID);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackID(_self->ob_itself);
{
PyObject *_res = NULL;
Movie _rv;
+#ifndef GetTrackMovie
+ PyMac_PRECHECK(GetTrackMovie);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackMovie(_self->ob_itself);
{
PyObject *_res = NULL;
unsigned long _rv;
+#ifndef GetTrackCreationTime
+ PyMac_PRECHECK(GetTrackCreationTime);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackCreationTime(_self->ob_itself);
{
PyObject *_res = NULL;
unsigned long _rv;
+#ifndef GetTrackModificationTime
+ PyMac_PRECHECK(GetTrackModificationTime);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackModificationTime(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef GetTrackEnabled
+ PyMac_PRECHECK(GetTrackEnabled);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackEnabled(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean isEnabled;
+#ifndef SetTrackEnabled
+ PyMac_PRECHECK(SetTrackEnabled);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&isEnabled))
return NULL;
{
PyObject *_res = NULL;
long _rv;
+#ifndef GetTrackUsage
+ PyMac_PRECHECK(GetTrackUsage);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackUsage(_self->ob_itself);
{
PyObject *_res = NULL;
long usage;
+#ifndef SetTrackUsage
+ PyMac_PRECHECK(SetTrackUsage);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&usage))
return NULL;
{
PyObject *_res = NULL;
TimeValue _rv;
+#ifndef GetTrackDuration
+ PyMac_PRECHECK(GetTrackDuration);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackDuration(_self->ob_itself);
{
PyObject *_res = NULL;
TimeValue _rv;
+#ifndef GetTrackOffset
+ PyMac_PRECHECK(GetTrackOffset);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackOffset(_self->ob_itself);
{
PyObject *_res = NULL;
TimeValue movieOffsetTime;
+#ifndef SetTrackOffset
+ PyMac_PRECHECK(SetTrackOffset);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&movieOffsetTime))
return NULL;
{
PyObject *_res = NULL;
short _rv;
+#ifndef GetTrackLayer
+ PyMac_PRECHECK(GetTrackLayer);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackLayer(_self->ob_itself);
{
PyObject *_res = NULL;
short layer;
+#ifndef SetTrackLayer
+ PyMac_PRECHECK(SetTrackLayer);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&layer))
return NULL;
{
PyObject *_res = NULL;
Track _rv;
+#ifndef GetTrackAlternate
+ PyMac_PRECHECK(GetTrackAlternate);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackAlternate(_self->ob_itself);
{
PyObject *_res = NULL;
Track alternateT;
+#ifndef SetTrackAlternate
+ PyMac_PRECHECK(SetTrackAlternate);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
TrackObj_Convert, &alternateT))
return NULL;
{
PyObject *_res = NULL;
short _rv;
+#ifndef GetTrackVolume
+ PyMac_PRECHECK(GetTrackVolume);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackVolume(_self->ob_itself);
{
PyObject *_res = NULL;
short volume;
+#ifndef SetTrackVolume
+ PyMac_PRECHECK(SetTrackVolume);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&volume))
return NULL;
PyObject *_res = NULL;
Fixed width;
Fixed height;
+#ifndef GetTrackDimensions
+ PyMac_PRECHECK(GetTrackDimensions);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetTrackDimensions(_self->ob_itself,
PyObject *_res = NULL;
Fixed width;
Fixed height;
+#ifndef SetTrackDimensions
+ PyMac_PRECHECK(SetTrackDimensions);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetFixed, &width,
PyMac_GetFixed, &height))
{
PyObject *_res = NULL;
UserData _rv;
+#ifndef GetTrackUserData
+ PyMac_PRECHECK(GetTrackUserData);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackUserData(_self->ob_itself);
PyObject *_res = NULL;
OSErr _err;
Handle settings;
+#ifndef GetTrackSoundLocalizationSettings
+ PyMac_PRECHECK(GetTrackSoundLocalizationSettings);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetTrackSoundLocalizationSettings(_self->ob_itself,
PyObject *_res = NULL;
OSErr _err;
Handle settings;
+#ifndef SetTrackSoundLocalizationSettings
+ PyMac_PRECHECK(SetTrackSoundLocalizationSettings);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &settings))
return NULL;
TimeScale timeScale;
Handle dataRef;
OSType dataRefType;
+#ifndef NewTrackMedia
+ PyMac_PRECHECK(NewTrackMedia);
+#endif
if (!PyArg_ParseTuple(_args, "O&lO&O&",
PyMac_GetOSType, &mediaType,
&timeScale,
{
PyObject *_res = NULL;
Media _rv;
+#ifndef GetTrackMedia
+ PyMac_PRECHECK(GetTrackMedia);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackMedia(_self->ob_itself);
TimeValue mediaTime;
TimeValue mediaDuration;
Fixed mediaRate;
+#ifndef InsertMediaIntoTrack
+ PyMac_PRECHECK(InsertMediaIntoTrack);
+#endif
if (!PyArg_ParseTuple(_args, "lllO&",
&trackStart,
&mediaTime,
TimeValue srcIn;
TimeValue srcDuration;
TimeValue dstIn;
+#ifndef InsertTrackSegment
+ PyMac_PRECHECK(InsertTrackSegment);
+#endif
if (!PyArg_ParseTuple(_args, "O&lll",
TrackObj_Convert, &dstTrack,
&srcIn,
OSErr _err;
TimeValue dstIn;
TimeValue dstDuration;
+#ifndef InsertEmptyTrackSegment
+ PyMac_PRECHECK(InsertEmptyTrackSegment);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&dstIn,
&dstDuration))
OSErr _err;
TimeValue startTime;
TimeValue duration;
+#ifndef DeleteTrackSegment
+ PyMac_PRECHECK(DeleteTrackSegment);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&startTime,
&duration))
TimeValue startTime;
TimeValue oldDuration;
TimeValue newDuration;
+#ifndef ScaleTrackSegment
+ PyMac_PRECHECK(ScaleTrackSegment);
+#endif
if (!PyArg_ParseTuple(_args, "lll",
&startTime,
&oldDuration,
{
PyObject *_res = NULL;
Component _rv;
+#ifndef IsScrapMovie
+ PyMac_PRECHECK(IsScrapMovie);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = IsScrapMovie(_self->ob_itself);
PyObject *_res = NULL;
OSErr _err;
Track dstTrack;
+#ifndef CopyTrackSettings
+ PyMac_PRECHECK(CopyTrackSettings);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
TrackObj_Convert, &dstTrack))
return NULL;
Handle dataRef;
OSType dataRefType;
Track dstTrack;
+#ifndef AddEmptyTrackToMovie
+ PyMac_PRECHECK(AddEmptyTrackToMovie);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
MovieObj_Convert, &dstMovie,
ResObj_Convert, &dataRef,
Movie dstMovie;
long flags;
Track dstTrack;
+#ifndef AddClonedTrackToMovie
+ PyMac_PRECHECK(AddClonedTrackToMovie);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
MovieObj_Convert, &dstMovie,
&flags))
Track refTrack;
OSType refType;
long addedIndex;
+#ifndef AddTrackReference
+ PyMac_PRECHECK(AddTrackReference);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
TrackObj_Convert, &refTrack,
PyMac_GetOSType, &refType))
OSErr _err;
OSType refType;
long index;
+#ifndef DeleteTrackReference
+ PyMac_PRECHECK(DeleteTrackReference);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetOSType, &refType,
&index))
Track refTrack;
OSType refType;
long index;
+#ifndef SetTrackReference
+ PyMac_PRECHECK(SetTrackReference);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&l",
TrackObj_Convert, &refTrack,
PyMac_GetOSType, &refType,
Track _rv;
OSType refType;
long index;
+#ifndef GetTrackReference
+ PyMac_PRECHECK(GetTrackReference);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetOSType, &refType,
&index))
PyObject *_res = NULL;
OSType _rv;
OSType refType;
+#ifndef GetNextTrackReferenceType
+ PyMac_PRECHECK(GetNextTrackReferenceType);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetOSType, &refType))
return NULL;
PyObject *_res = NULL;
long _rv;
OSType refType;
+#ifndef GetTrackReferenceCount
+ PyMac_PRECHECK(GetTrackReferenceCount);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetOSType, &refType))
return NULL;
PyObject *_res = NULL;
Fixed _rv;
TimeValue atTime;
+#ifndef GetTrackEditRate
+ PyMac_PRECHECK(GetTrackEditRate);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&atTime))
return NULL;
long _rv;
TimeValue startTime;
TimeValue duration;
+#ifndef GetTrackDataSize
+ PyMac_PRECHECK(GetTrackDataSize);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&startTime,
&duration))
TimeValue startTime;
TimeValue duration;
wide dataSize;
+#ifndef GetTrackDataSize64
+ PyMac_PRECHECK(GetTrackDataSize64);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&startTime,
&duration))
PyObject *_res = NULL;
Boolean _rv;
Point pt;
+#ifndef PtInTrack
+ PyMac_PRECHECK(PtInTrack);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetPoint, &pt))
return NULL;
Fixed rate;
TimeValue interestingTime;
TimeValue interestingDuration;
+#ifndef GetTrackNextInterestingTime
+ PyMac_PRECHECK(GetTrackNextInterestingTime);
+#endif
if (!PyArg_ParseTuple(_args, "hlO&",
&interestingTimeFlags,
&time,
RgnHandle _rv;
TimeValue time;
TimeValue duration;
+#ifndef GetTrackSegmentDisplayBoundsRgn
+ PyMac_PRECHECK(GetTrackSegmentDisplayBoundsRgn);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&time,
&duration))
{
PyObject *_res = NULL;
ComponentResult _rv;
+#ifndef GetTrackStatus
+ PyMac_PRECHECK(GetTrackStatus);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetTrackStatus(_self->ob_itself);
TimeValue preloadDuration;
long preloadFlags;
long defaultHints;
+#ifndef SetTrackLoadSettings
+ PyMac_PRECHECK(SetTrackLoadSettings);
+#endif
if (!PyArg_ParseTuple(_args, "llll",
&preloadTime,
&preloadDuration,
TimeValue preloadDuration;
long preloadFlags;
long defaultHints;
+#ifndef GetTrackLoadSettings
+ PyMac_PRECHECK(GetTrackLoadSettings);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetTrackLoadSettings(_self->ob_itself,
{
PyObject *_res = NULL;
long maxMilliSecToUse;
+#ifndef MoviesTask
+ PyMac_PRECHECK(MoviesTask);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&maxMilliSecToUse))
return NULL;
OSErr _err;
TimeValue time;
Fixed Rate;
+#ifndef PrerollMovie
+ PyMac_PRECHECK(PrerollMovie);
+#endif
if (!PyArg_ParseTuple(_args, "lO&",
&time,
PyMac_GetFixed, &Rate))
{
PyObject *_res = NULL;
OSErr err;
+#ifndef AbortPrePrerollMovie
+ PyMac_PRECHECK(AbortPrePrerollMovie);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&err))
return NULL;
TimeValue time;
TimeValue duration;
long flags;
+#ifndef LoadMovieIntoRam
+ PyMac_PRECHECK(LoadMovieIntoRam);
+#endif
if (!PyArg_ParseTuple(_args, "lll",
&time,
&duration,
{
PyObject *_res = NULL;
Boolean active;
+#ifndef SetMovieActive
+ PyMac_PRECHECK(SetMovieActive);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&active))
return NULL;
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef GetMovieActive
+ PyMac_PRECHECK(GetMovieActive);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMovieActive(_self->ob_itself);
static PyObject *MovieObj_StartMovie(MovieObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef StartMovie
+ PyMac_PRECHECK(StartMovie);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
StartMovie(_self->ob_itself);
static PyObject *MovieObj_StopMovie(MovieObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef StopMovie
+ PyMac_PRECHECK(StopMovie);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
StopMovie(_self->ob_itself);
static PyObject *MovieObj_GoToBeginningOfMovie(MovieObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef GoToBeginningOfMovie
+ PyMac_PRECHECK(GoToBeginningOfMovie);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GoToBeginningOfMovie(_self->ob_itself);
static PyObject *MovieObj_GoToEndOfMovie(MovieObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef GoToEndOfMovie
+ PyMac_PRECHECK(GoToEndOfMovie);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GoToEndOfMovie(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef IsMovieDone
+ PyMac_PRECHECK(IsMovieDone);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = IsMovieDone(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef GetMoviePreviewMode
+ PyMac_PRECHECK(GetMoviePreviewMode);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMoviePreviewMode(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean usePreview;
+#ifndef SetMoviePreviewMode
+ PyMac_PRECHECK(SetMoviePreviewMode);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&usePreview))
return NULL;
static PyObject *MovieObj_ShowMoviePoster(MovieObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef ShowMoviePoster
+ PyMac_PRECHECK(ShowMoviePoster);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
ShowMoviePoster(_self->ob_itself);
{
PyObject *_res = NULL;
TimeBase _rv;
+#ifndef GetMovieTimeBase
+ PyMac_PRECHECK(GetMovieTimeBase);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMovieTimeBase(_self->ob_itself);
PyObject *_res = NULL;
TimeBase tb;
TimeRecord slaveZero;
+#ifndef SetMovieMasterTimeBase
+ PyMac_PRECHECK(SetMovieMasterTimeBase);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
TimeBaseObj_Convert, &tb,
QtTimeRecord_Convert, &slaveZero))
PyObject *_res = NULL;
Component clockMeister;
TimeRecord slaveZero;
+#ifndef SetMovieMasterClock
+ PyMac_PRECHECK(SetMovieMasterClock);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
CmpObj_Convert, &clockMeister,
QtTimeRecord_Convert, &slaveZero))
PyObject *_res = NULL;
CGrafPtr port;
GDHandle gdh;
+#ifndef GetMovieGWorld
+ PyMac_PRECHECK(GetMovieGWorld);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetMovieGWorld(_self->ob_itself,
PyObject *_res = NULL;
CGrafPtr port;
GDHandle gdh;
+#ifndef SetMovieGWorld
+ PyMac_PRECHECK(SetMovieGWorld);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
GrafObj_Convert, &port,
OptResObj_Convert, &gdh))
{
PyObject *_res = NULL;
Rect naturalBounds;
+#ifndef GetMovieNaturalBoundsRect
+ PyMac_PRECHECK(GetMovieNaturalBoundsRect);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetMovieNaturalBoundsRect(_self->ob_itself,
PyObject *_res = NULL;
Track _rv;
Track theTrack;
+#ifndef GetNextTrackForCompositing
+ PyMac_PRECHECK(GetNextTrackForCompositing);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
TrackObj_Convert, &theTrack))
return NULL;
PyObject *_res = NULL;
Track _rv;
Track theTrack;
+#ifndef GetPrevTrackForCompositing
+ PyMac_PRECHECK(GetPrevTrackForCompositing);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
TrackObj_Convert, &theTrack))
return NULL;
PyObject *_res = NULL;
PicHandle _rv;
TimeValue time;
+#ifndef GetMoviePict
+ PyMac_PRECHECK(GetMoviePict);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&time))
return NULL;
{
PyObject *_res = NULL;
PicHandle _rv;
+#ifndef GetMoviePosterPict
+ PyMac_PRECHECK(GetMoviePosterPict);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMoviePosterPict(_self->ob_itself);
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef UpdateMovie
+ PyMac_PRECHECK(UpdateMovie);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = UpdateMovie(_self->ob_itself);
PyObject *_res = NULL;
OSErr _err;
RgnHandle invalidRgn;
+#ifndef InvalidateMovieRegion
+ PyMac_PRECHECK(InvalidateMovieRegion);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &invalidRgn))
return NULL;
{
PyObject *_res = NULL;
Rect boxRect;
+#ifndef GetMovieBox
+ PyMac_PRECHECK(GetMovieBox);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetMovieBox(_self->ob_itself,
{
PyObject *_res = NULL;
Rect boxRect;
+#ifndef SetMovieBox
+ PyMac_PRECHECK(SetMovieBox);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &boxRect))
return NULL;
{
PyObject *_res = NULL;
RgnHandle _rv;
+#ifndef GetMovieDisplayClipRgn
+ PyMac_PRECHECK(GetMovieDisplayClipRgn);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMovieDisplayClipRgn(_self->ob_itself);
{
PyObject *_res = NULL;
RgnHandle theClip;
+#ifndef SetMovieDisplayClipRgn
+ PyMac_PRECHECK(SetMovieDisplayClipRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &theClip))
return NULL;
{
PyObject *_res = NULL;
RgnHandle _rv;
+#ifndef GetMovieClipRgn
+ PyMac_PRECHECK(GetMovieClipRgn);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMovieClipRgn(_self->ob_itself);
{
PyObject *_res = NULL;
RgnHandle theClip;
+#ifndef SetMovieClipRgn
+ PyMac_PRECHECK(SetMovieClipRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &theClip))
return NULL;
{
PyObject *_res = NULL;
RgnHandle _rv;
+#ifndef GetMovieDisplayBoundsRgn
+ PyMac_PRECHECK(GetMovieDisplayBoundsRgn);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMovieDisplayBoundsRgn(_self->ob_itself);
{
PyObject *_res = NULL;
RgnHandle _rv;
+#ifndef GetMovieBoundsRgn
+ PyMac_PRECHECK(GetMovieBoundsRgn);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMovieBoundsRgn(_self->ob_itself);
{
PyObject *_res = NULL;
ComponentInstance vout;
+#ifndef SetMovieVideoOutput
+ PyMac_PRECHECK(SetMovieVideoOutput);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CmpInstObj_Convert, &vout))
return NULL;
PyObject *_res = NULL;
OSErr _err;
Handle publicMovie;
+#ifndef PutMovieIntoHandle
+ PyMac_PRECHECK(PutMovieIntoHandle);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &publicMovie))
return NULL;
short fRefNum;
long offset;
long maxSize;
+#ifndef PutMovieIntoDataFork
+ PyMac_PRECHECK(PutMovieIntoDataFork);
+#endif
if (!PyArg_ParseTuple(_args, "hll",
&fRefNum,
&offset,
long fRefNum;
wide offset;
unsigned long maxSize;
+#ifndef PutMovieIntoDataFork64
+ PyMac_PRECHECK(PutMovieIntoDataFork64);
+#endif
if (!PyArg_ParseTuple(_args, "lO&l",
&fRefNum,
PyMac_Getwide, &offset,
{
PyObject *_res = NULL;
unsigned long _rv;
+#ifndef GetMovieCreationTime
+ PyMac_PRECHECK(GetMovieCreationTime);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMovieCreationTime(_self->ob_itself);
{
PyObject *_res = NULL;
unsigned long _rv;
+#ifndef GetMovieModificationTime
+ PyMac_PRECHECK(GetMovieModificationTime);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMovieModificationTime(_self->ob_itself);
{
PyObject *_res = NULL;
TimeScale _rv;
+#ifndef GetMovieTimeScale
+ PyMac_PRECHECK(GetMovieTimeScale);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMovieTimeScale(_self->ob_itself);
{
PyObject *_res = NULL;
TimeScale timeScale;
+#ifndef SetMovieTimeScale
+ PyMac_PRECHECK(SetMovieTimeScale);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&timeScale))
return NULL;
{
PyObject *_res = NULL;
TimeValue _rv;
+#ifndef GetMovieDuration
+ PyMac_PRECHECK(GetMovieDuration);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMovieDuration(_self->ob_itself);
{
PyObject *_res = NULL;
Fixed _rv;
+#ifndef GetMovieRate
+ PyMac_PRECHECK(GetMovieRate);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMovieRate(_self->ob_itself);
{
PyObject *_res = NULL;
Fixed rate;
+#ifndef SetMovieRate
+ PyMac_PRECHECK(SetMovieRate);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetFixed, &rate))
return NULL;
{
PyObject *_res = NULL;
Fixed _rv;
+#ifndef GetMoviePreferredRate
+ PyMac_PRECHECK(GetMoviePreferredRate);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMoviePreferredRate(_self->ob_itself);
{
PyObject *_res = NULL;
Fixed rate;
+#ifndef SetMoviePreferredRate
+ PyMac_PRECHECK(SetMoviePreferredRate);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetFixed, &rate))
return NULL;
{
PyObject *_res = NULL;
short _rv;
+#ifndef GetMoviePreferredVolume
+ PyMac_PRECHECK(GetMoviePreferredVolume);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMoviePreferredVolume(_self->ob_itself);
{
PyObject *_res = NULL;
short volume;
+#ifndef SetMoviePreferredVolume
+ PyMac_PRECHECK(SetMoviePreferredVolume);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&volume))
return NULL;
{
PyObject *_res = NULL;
short _rv;
+#ifndef GetMovieVolume
+ PyMac_PRECHECK(GetMovieVolume);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMovieVolume(_self->ob_itself);
{
PyObject *_res = NULL;
short volume;
+#ifndef SetMovieVolume
+ PyMac_PRECHECK(SetMovieVolume);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&volume))
return NULL;
PyObject *_res = NULL;
TimeValue previewTime;
TimeValue previewDuration;
+#ifndef GetMoviePreviewTime
+ PyMac_PRECHECK(GetMoviePreviewTime);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetMoviePreviewTime(_self->ob_itself,
PyObject *_res = NULL;
TimeValue previewTime;
TimeValue previewDuration;
+#ifndef SetMoviePreviewTime
+ PyMac_PRECHECK(SetMoviePreviewTime);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&previewTime,
&previewDuration))
{
PyObject *_res = NULL;
TimeValue _rv;
+#ifndef GetMoviePosterTime
+ PyMac_PRECHECK(GetMoviePosterTime);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMoviePosterTime(_self->ob_itself);
{
PyObject *_res = NULL;
TimeValue posterTime;
+#ifndef SetMoviePosterTime
+ PyMac_PRECHECK(SetMoviePosterTime);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&posterTime))
return NULL;
PyObject *_res = NULL;
TimeValue selectionTime;
TimeValue selectionDuration;
+#ifndef GetMovieSelection
+ PyMac_PRECHECK(GetMovieSelection);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetMovieSelection(_self->ob_itself,
PyObject *_res = NULL;
TimeValue selectionTime;
TimeValue selectionDuration;
+#ifndef SetMovieSelection
+ PyMac_PRECHECK(SetMovieSelection);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&selectionTime,
&selectionDuration))
PyObject *_res = NULL;
TimeValue startTime;
TimeValue duration;
+#ifndef SetMovieActiveSegment
+ PyMac_PRECHECK(SetMovieActiveSegment);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&startTime,
&duration))
PyObject *_res = NULL;
TimeValue startTime;
TimeValue duration;
+#ifndef GetMovieActiveSegment
+ PyMac_PRECHECK(GetMovieActiveSegment);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetMovieActiveSegment(_self->ob_itself,
PyObject *_res = NULL;
TimeValue _rv;
TimeRecord currentTime;
+#ifndef GetMovieTime
+ PyMac_PRECHECK(GetMovieTime);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMovieTime(_self->ob_itself,
{
PyObject *_res = NULL;
TimeRecord newtime;
+#ifndef SetMovieTime
+ PyMac_PRECHECK(SetMovieTime);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
QtTimeRecord_Convert, &newtime))
return NULL;
{
PyObject *_res = NULL;
TimeValue newtime;
+#ifndef SetMovieTimeValue
+ PyMac_PRECHECK(SetMovieTimeValue);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&newtime))
return NULL;
{
PyObject *_res = NULL;
UserData _rv;
+#ifndef GetMovieUserData
+ PyMac_PRECHECK(GetMovieUserData);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMovieUserData(_self->ob_itself);
{
PyObject *_res = NULL;
long _rv;
+#ifndef GetMovieTrackCount
+ PyMac_PRECHECK(GetMovieTrackCount);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMovieTrackCount(_self->ob_itself);
PyObject *_res = NULL;
Track _rv;
long trackID;
+#ifndef GetMovieTrack
+ PyMac_PRECHECK(GetMovieTrack);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&trackID))
return NULL;
PyObject *_res = NULL;
Track _rv;
long index;
+#ifndef GetMovieIndTrack
+ PyMac_PRECHECK(GetMovieIndTrack);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&index))
return NULL;
long index;
OSType trackType;
long flags;
+#ifndef GetMovieIndTrackType
+ PyMac_PRECHECK(GetMovieIndTrackType);
+#endif
if (!PyArg_ParseTuple(_args, "lO&l",
&index,
PyMac_GetOSType, &trackType,
Fixed width;
Fixed height;
short trackVolume;
+#ifndef NewMovieTrack
+ PyMac_PRECHECK(NewMovieTrack);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&h",
PyMac_GetFixed, &width,
PyMac_GetFixed, &height,
{
PyObject *_res = NULL;
Boolean enable;
+#ifndef SetAutoTrackAlternatesEnabled
+ PyMac_PRECHECK(SetAutoTrackAlternatesEnabled);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&enable))
return NULL;
static PyObject *MovieObj_SelectMovieAlternates(MovieObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef SelectMovieAlternates
+ PyMac_PRECHECK(SelectMovieAlternates);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
SelectMovieAlternates(_self->ob_itself);
TimeValue srcIn;
TimeValue srcDuration;
TimeValue dstIn;
+#ifndef InsertMovieSegment
+ PyMac_PRECHECK(InsertMovieSegment);
+#endif
if (!PyArg_ParseTuple(_args, "O&lll",
MovieObj_Convert, &dstMovie,
&srcIn,
OSErr _err;
TimeValue dstIn;
TimeValue dstDuration;
+#ifndef InsertEmptyMovieSegment
+ PyMac_PRECHECK(InsertEmptyMovieSegment);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&dstIn,
&dstDuration))
OSErr _err;
TimeValue startTime;
TimeValue duration;
+#ifndef DeleteMovieSegment
+ PyMac_PRECHECK(DeleteMovieSegment);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&startTime,
&duration))
TimeValue startTime;
TimeValue oldDuration;
TimeValue newDuration;
+#ifndef ScaleMovieSegment
+ PyMac_PRECHECK(ScaleMovieSegment);
+#endif
if (!PyArg_ParseTuple(_args, "lll",
&startTime,
&oldDuration,
{
PyObject *_res = NULL;
Movie _rv;
+#ifndef CutMovieSelection
+ PyMac_PRECHECK(CutMovieSelection);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CutMovieSelection(_self->ob_itself);
{
PyObject *_res = NULL;
Movie _rv;
+#ifndef CopyMovieSelection
+ PyMac_PRECHECK(CopyMovieSelection);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CopyMovieSelection(_self->ob_itself);
{
PyObject *_res = NULL;
Movie src;
+#ifndef PasteMovieSelection
+ PyMac_PRECHECK(PasteMovieSelection);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
MovieObj_Convert, &src))
return NULL;
{
PyObject *_res = NULL;
Movie src;
+#ifndef AddMovieSelection
+ PyMac_PRECHECK(AddMovieSelection);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
MovieObj_Convert, &src))
return NULL;
static PyObject *MovieObj_ClearMovieSelection(MovieObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef ClearMovieSelection
+ PyMac_PRECHECK(ClearMovieSelection);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
ClearMovieSelection(_self->ob_itself);
TimeValue dur;
long flags;
ComponentInstance userComp;
+#ifndef PutMovieIntoTypedHandle
+ PyMac_PRECHECK(PutMovieIntoTypedHandle);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&lllO&",
TrackObj_Convert, &targetTrack,
PyMac_GetOSType, &handleType,
PyObject *_res = NULL;
OSErr _err;
Movie dstMovie;
+#ifndef CopyMovieSettings
+ PyMac_PRECHECK(CopyMovieSettings);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
MovieObj_Convert, &dstMovie))
return NULL;
short resID;
long flags;
ComponentInstance userComp;
+#ifndef ConvertMovieToFile
+ PyMac_PRECHECK(ConvertMovieToFile);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&O&hlO&",
TrackObj_Convert, &onlyTrack,
PyMac_GetFSSpec, &outputFile,
long _rv;
TimeValue startTime;
TimeValue duration;
+#ifndef GetMovieDataSize
+ PyMac_PRECHECK(GetMovieDataSize);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&startTime,
&duration))
TimeValue startTime;
TimeValue duration;
wide dataSize;
+#ifndef GetMovieDataSize64
+ PyMac_PRECHECK(GetMovieDataSize64);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&startTime,
&duration))
PyObject *_res = NULL;
Boolean _rv;
Point pt;
+#ifndef PtInMovie
+ PyMac_PRECHECK(PtInMovie);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetPoint, &pt))
return NULL;
{
PyObject *_res = NULL;
long language;
+#ifndef SetMovieLanguage
+ PyMac_PRECHECK(SetMovieLanguage);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&language))
return NULL;
Fixed rate;
TimeValue interestingTime;
TimeValue interestingDuration;
+#ifndef GetMovieNextInterestingTime
+ PyMac_PRECHECK(GetMovieNextInterestingTime);
+#endif
if (!PyArg_ParseTuple(_args, "hhO&lO&",
&interestingTimeFlags,
&numMediaTypes,
short resRefNum;
short resId;
Str255 resName;
+#ifndef AddMovieResource
+ PyMac_PRECHECK(AddMovieResource);
+#endif
if (!PyArg_ParseTuple(_args, "hO&",
&resRefNum,
PyMac_GetStr255, resName))
short resRefNum;
short resId;
Str255 resName;
+#ifndef UpdateMovieResource
+ PyMac_PRECHECK(UpdateMovieResource);
+#endif
if (!PyArg_ParseTuple(_args, "hhO&",
&resRefNum,
&resId,
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef HasMovieChanged
+ PyMac_PRECHECK(HasMovieChanged);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = HasMovieChanged(_self->ob_itself);
static PyObject *MovieObj_ClearMovieChanged(MovieObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef ClearMovieChanged
+ PyMac_PRECHECK(ClearMovieChanged);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
ClearMovieChanged(_self->ob_itself);
OSErr _err;
Handle dataRef;
OSType dataRefType;
+#ifndef SetMovieDefaultDataRef
+ PyMac_PRECHECK(SetMovieDefaultDataRef);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &dataRef,
PyMac_GetOSType, &dataRefType))
OSErr _err;
Handle dataRef;
OSType dataRefType;
+#ifndef GetMovieDefaultDataRef
+ PyMac_PRECHECK(GetMovieDefaultDataRef);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetMovieDefaultDataRef(_self->ob_itself,
OSErr _err;
Handle dataRef;
OSType dataRefType;
+#ifndef SetMovieAnchorDataRef
+ PyMac_PRECHECK(SetMovieAnchorDataRef);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &dataRef,
PyMac_GetOSType, &dataRefType))
Handle dataRef;
OSType dataRefType;
long outFlags;
+#ifndef GetMovieAnchorDataRef
+ PyMac_PRECHECK(GetMovieAnchorDataRef);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetMovieAnchorDataRef(_self->ob_itself,
PyObject *_res = NULL;
OSErr _err;
CTabHandle ctab;
+#ifndef SetMovieColorTable
+ PyMac_PRECHECK(SetMovieColorTable);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &ctab))
return NULL;
PyObject *_res = NULL;
OSErr _err;
CTabHandle ctab;
+#ifndef GetMovieColorTable
+ PyMac_PRECHECK(GetMovieColorTable);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetMovieColorTable(_self->ob_itself,
long createMovieFileFlags;
short resId;
Str255 resName;
+#ifndef FlattenMovie
+ PyMac_PRECHECK(FlattenMovie);
+#endif
if (!PyArg_ParseTuple(_args, "lO&O&hlO&",
&movieFlattenFlags,
PyMac_GetFSSpec, &theFile,
OSType creator;
ScriptCode scriptTag;
long createMovieFileFlags;
+#ifndef FlattenMovieData
+ PyMac_PRECHECK(FlattenMovieData);
+#endif
if (!PyArg_ParseTuple(_args, "lO&O&hl",
&movieFlattenFlags,
PyMac_GetFSSpec, &theFile,
Track searchTrack;
TimeValue searchTime;
long searchOffset;
+#ifndef MovieSearchText
+ PyMac_PRECHECK(MovieSearchText);
+#endif
if (!PyArg_ParseTuple(_args, "sll",
&text,
&size,
{
PyObject *_res = NULL;
Rect boxRect;
+#ifndef GetPosterBox
+ PyMac_PRECHECK(GetPosterBox);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetPosterBox(_self->ob_itself,
{
PyObject *_res = NULL;
Rect boxRect;
+#ifndef SetPosterBox
+ PyMac_PRECHECK(SetPosterBox);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &boxRect))
return NULL;
RgnHandle _rv;
TimeValue time;
TimeValue duration;
+#ifndef GetMovieSegmentDisplayBoundsRgn
+ PyMac_PRECHECK(GetMovieSegmentDisplayBoundsRgn);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&time,
&duration))
PyObject *_res = NULL;
ComponentResult _rv;
Track firstProblemTrack;
+#ifndef GetMovieStatus
+ PyMac_PRECHECK(GetMovieStatus);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMovieStatus(_self->ob_itself,
{
PyObject *_res = NULL;
long _rv;
+#ifndef GetMovieLoadState
+ PyMac_PRECHECK(GetMovieLoadState);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMovieLoadState(_self->ob_itself);
MovieController _rv;
Rect movieRect;
long someFlags;
+#ifndef NewMovieController
+ PyMac_PRECHECK(NewMovieController);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetRect, &movieRect,
&someFlags))
PyObject *_res = NULL;
OSErr _err;
long movieScrapFlags;
+#ifndef PutMovieOnScrap
+ PyMac_PRECHECK(PutMovieOnScrap);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&movieScrapFlags))
return NULL;
PyObject *_res = NULL;
long flags;
long flagsMask;
+#ifndef SetMoviePlayHints
+ PyMac_PRECHECK(SetMoviePlayHints);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&flags,
&flagsMask))
PyObject *_res = NULL;
OSErr _err;
TimeValue time;
+#ifndef GetMaxLoadedTimeInMovie
+ PyMac_PRECHECK(GetMaxLoadedTimeInMovie);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetMaxLoadedTimeInMovie(_self->ob_itself,
PyObject *_res = NULL;
OSErr _err;
Boolean needsTimeTable;
+#ifndef QTMovieNeedsTimeTable
+ PyMac_PRECHECK(QTMovieNeedsTimeTable);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = QTMovieNeedsTimeTable(_self->ob_itself,
OSType dataRefType;
Handle dataRef;
long offset;
+#ifndef QTGetDataRefMaxFileOffset
+ PyMac_PRECHECK(QTGetDataRefMaxFileOffset);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetOSType, &dataRefType,
ResObj_Convert, &dataRef))
PyObject *_res = NULL;
void * registrationKey;
long flags;
+#ifndef CheckQuickTimeRegistration
+ PyMac_PRECHECK(CheckQuickTimeRegistration);
+#endif
if (!PyArg_ParseTuple(_args, "sl",
®istrationKey,
&flags))
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef EnterMovies
+ PyMac_PRECHECK(EnterMovies);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = EnterMovies();
static PyObject *Qt_ExitMovies(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef ExitMovies
+ PyMac_PRECHECK(ExitMovies);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
ExitMovies();
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef GetMoviesError
+ PyMac_PRECHECK(GetMoviesError);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetMoviesError();
static PyObject *Qt_ClearMoviesStickyError(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef ClearMoviesStickyError
+ PyMac_PRECHECK(ClearMoviesStickyError);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
ClearMoviesStickyError();
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef GetMoviesStickyError
+ PyMac_PRECHECK(GetMoviesStickyError);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetMoviesStickyError();
{
PyObject *_res = NULL;
PixMapHandle theMatte;
+#ifndef DisposeMatte
+ PyMac_PRECHECK(DisposeMatte);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &theMatte))
return NULL;
PyObject *_res = NULL;
Movie _rv;
long flags;
+#ifndef NewMovie
+ PyMac_PRECHECK(NewMovie);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&flags))
return NULL;
Handle dataRef;
OSType dataHandlerSubType;
long flags;
+#ifndef GetDataHandler
+ PyMac_PRECHECK(GetDataHandler);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&l",
ResObj_Convert, &dataRef,
PyMac_GetOSType, &dataHandlerSubType,
TimeBase tb;
long flags;
ComponentInstance dh;
+#ifndef OpenADataHandler
+ PyMac_PRECHECK(OpenADataHandler);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&O&O&l",
ResObj_Convert, &dataRef,
PyMac_GetOSType, &dataHandlerSubType,
Movie theMovie;
long flags;
ComponentInstance userComp;
+#ifndef PasteHandleIntoMovie
+ PyMac_PRECHECK(PasteHandleIntoMovie);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&lO&",
ResObj_Convert, &h,
PyMac_GetOSType, &handleType,
Handle dataRef;
long flags;
Component importer;
+#ifndef GetMovieImporterForDataRef
+ PyMac_PRECHECK(GetMovieImporterForDataRef);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&l",
PyMac_GetOSType, &dataRefType,
ResObj_Convert, &dataRef,
OSType infoSelector;
void * infoDataPtr;
long infoDataSize;
+#ifndef QTGetMIMETypeInfo
+ PyMac_PRECHECK(QTGetMIMETypeInfo);
+#endif
if (!PyArg_ParseTuple(_args, "shO&s",
&mimeStringStart,
&mimeStringLength,
TimeValue _rv;
TimeValue value;
Track theTrack;
+#ifndef TrackTimeToMediaTime
+ PyMac_PRECHECK(TrackTimeToMediaTime);
+#endif
if (!PyArg_ParseTuple(_args, "lO&",
&value,
TrackObj_Convert, &theTrack))
PyObject *_res = NULL;
OSErr _err;
UserData theUserData;
+#ifndef NewUserData
+ PyMac_PRECHECK(NewUserData);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = NewUserData(&theUserData);
OSErr _err;
Handle h;
UserData theUserData;
+#ifndef NewUserDataFromHandle
+ PyMac_PRECHECK(NewUserDataFromHandle);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &h))
return NULL;
long createMovieFileFlags;
short resRefNum;
Movie newmovie;
+#ifndef CreateMovieFile
+ PyMac_PRECHECK(CreateMovieFile);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&hl",
PyMac_GetFSSpec, &fileSpec,
PyMac_GetOSType, &creator,
FSSpec fileSpec;
short resRefNum;
SInt8 permission;
+#ifndef OpenMovieFile
+ PyMac_PRECHECK(OpenMovieFile);
+#endif
if (!PyArg_ParseTuple(_args, "O&b",
PyMac_GetFSSpec, &fileSpec,
&permission))
PyObject *_res = NULL;
OSErr _err;
short resRefNum;
+#ifndef CloseMovieFile
+ PyMac_PRECHECK(CloseMovieFile);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&resRefNum))
return NULL;
PyObject *_res = NULL;
OSErr _err;
FSSpec fileSpec;
+#ifndef DeleteMovieFile
+ PyMac_PRECHECK(DeleteMovieFile);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetFSSpec, &fileSpec))
return NULL;
short resId;
short newMovieFlags;
Boolean dataRefWasChanged;
+#ifndef NewMovieFromFile
+ PyMac_PRECHECK(NewMovieFromFile);
+#endif
if (!PyArg_ParseTuple(_args, "hhh",
&resRefNum,
&resId,
Handle h;
short newMovieFlags;
Boolean dataRefWasChanged;
+#ifndef NewMovieFromHandle
+ PyMac_PRECHECK(NewMovieFromHandle);
+#endif
if (!PyArg_ParseTuple(_args, "O&h",
ResObj_Convert, &h,
&newMovieFlags))
long fileOffset;
short newMovieFlags;
Boolean dataRefWasChanged;
+#ifndef NewMovieFromDataFork
+ PyMac_PRECHECK(NewMovieFromDataFork);
+#endif
if (!PyArg_ParseTuple(_args, "hlh",
&fRefNum,
&fileOffset,
wide fileOffset;
short newMovieFlags;
Boolean dataRefWasChanged;
+#ifndef NewMovieFromDataFork64
+ PyMac_PRECHECK(NewMovieFromDataFork64);
+#endif
if (!PyArg_ParseTuple(_args, "lO&h",
&fRefNum,
PyMac_Getwide, &fileOffset,
short id;
Handle dataRef;
OSType dataRefType;
+#ifndef NewMovieFromDataRef
+ PyMac_PRECHECK(NewMovieFromDataRef);
+#endif
if (!PyArg_ParseTuple(_args, "hO&O&",
&flags,
ResObj_Convert, &dataRef,
OSErr _err;
short resRefNum;
short resId;
+#ifndef RemoveMovieResource
+ PyMac_PRECHECK(RemoveMovieResource);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&resRefNum,
&resId))
long createMovieFileFlags;
Handle targetDataRef;
OSType targetDataRefType;
+#ifndef CreateShortcutMovieFile
+ PyMac_PRECHECK(CreateShortcutMovieFile);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&hlO&O&",
PyMac_GetFSSpec, &fileSpec,
PyMac_GetOSType, &creator,
Boolean outCanOpenAsMovie;
Boolean outPreferGraphicsImporter;
UInt32 inFlags;
+#ifndef CanQuickTimeOpenFile
+ PyMac_PRECHECK(CanQuickTimeOpenFile);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&l",
PyMac_GetFSSpec, &fileSpec,
PyMac_GetOSType, &fileType,
Boolean outCanOpenAsMovie;
Boolean outPreferGraphicsImporter;
UInt32 inFlags;
+#ifndef CanQuickTimeOpenDataRef
+ PyMac_PRECHECK(CanQuickTimeOpenDataRef);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&l",
ResObj_Convert, &dataRef,
PyMac_GetOSType, &dataRefType,
PyObject *_res = NULL;
Movie _rv;
long newMovieFlags;
+#ifndef NewMovieFromScrap
+ PyMac_PRECHECK(NewMovieFromScrap);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&newMovieFlags))
return NULL;
FSSpec fss;
AliasHandle alias;
Boolean minimal;
+#ifndef QTNewAlias
+ PyMac_PRECHECK(QTNewAlias);
+#endif
if (!PyArg_ParseTuple(_args, "O&b",
PyMac_GetFSSpec, &fss,
&minimal))
OSErr _err;
Ptr fullState;
long flags;
+#ifndef EndFullScreen
+ PyMac_PRECHECK(EndFullScreen);
+#endif
if (!PyArg_ParseTuple(_args, "sl",
&fullState,
&flags))
SoundDescriptionHandle desc;
Handle extension;
OSType idType;
+#ifndef AddSoundDescriptionExtension
+ PyMac_PRECHECK(AddSoundDescriptionExtension);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
ResObj_Convert, &desc,
ResObj_Convert, &extension,
SoundDescriptionHandle desc;
Handle extension;
OSType idType;
+#ifndef GetSoundDescriptionExtension
+ PyMac_PRECHECK(GetSoundDescriptionExtension);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &desc,
PyMac_GetOSType, &idType))
OSErr _err;
SoundDescriptionHandle desc;
OSType idType;
+#ifndef RemoveSoundDescriptionExtension
+ PyMac_PRECHECK(RemoveSoundDescriptionExtension);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &desc,
PyMac_GetOSType, &idType))
OSErr _err;
EventRecord pEvent;
QTParameterDialog createdDialog;
+#ifndef QTIsStandardParameterDialogEvent
+ PyMac_PRECHECK(QTIsStandardParameterDialogEvent);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&createdDialog))
return NULL;
PyObject *_res = NULL;
OSErr _err;
QTParameterDialog createdDialog;
+#ifndef QTDismissStandardParameterDialog
+ PyMac_PRECHECK(QTDismissStandardParameterDialog);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&createdDialog))
return NULL;
QTParameterDialog createdDialog;
long action;
void * params;
+#ifndef QTStandardParameterDialogDoAction
+ PyMac_PRECHECK(QTStandardParameterDialogDoAction);
+#endif
if (!PyArg_ParseTuple(_args, "lls",
&createdDialog,
&action,
Str255 accessKeyType;
long flags;
Handle accessKey;
+#ifndef QTRegisterAccessKey
+ PyMac_PRECHECK(QTRegisterAccessKey);
+#endif
if (!PyArg_ParseTuple(_args, "O&lO&",
PyMac_GetStr255, accessKeyType,
&flags,
Str255 accessKeyType;
long flags;
Handle accessKey;
+#ifndef QTUnregisterAccessKey
+ PyMac_PRECHECK(QTUnregisterAccessKey);
+#endif
if (!PyArg_ParseTuple(_args, "O&lO&",
PyMac_GetStr255, accessKeyType,
&flags,
Handle theText;
long encoding;
long flags;
+#ifndef QTTextToNativeText
+ PyMac_PRECHECK(QTTextToNativeText);
+#endif
if (!PyArg_ParseTuple(_args, "O&ll",
ResObj_Convert, &theText,
&encoding,
PyObject *_res = NULL;
ComponentResult _rv;
MediaHandler mh;
+#ifndef VideoMediaResetStatistics
+ PyMac_PRECHECK(VideoMediaResetStatistics);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CmpInstObj_Convert, &mh))
return NULL;
PyObject *_res = NULL;
ComponentResult _rv;
MediaHandler mh;
+#ifndef VideoMediaGetStatistics
+ PyMac_PRECHECK(VideoMediaGetStatistics);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CmpInstObj_Convert, &mh))
return NULL;
ComponentResult _rv;
MediaHandler mh;
unsigned long stalls;
+#ifndef VideoMediaGetStallCount
+ PyMac_PRECHECK(VideoMediaGetStallCount);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CmpInstObj_Convert, &mh))
return NULL;
long parameterChangeSeed;
void * dataPtr;
long dataSize;
+#ifndef VideoMediaSetCodecParameter
+ PyMac_PRECHECK(VideoMediaSetCodecParameter);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&lsl",
CmpInstObj_Convert, &mh,
PyMac_GetOSType, &cType,
CodecType cType;
OSType parameterID;
Handle outParameterData;
+#ifndef VideoMediaGetCodecParameter
+ PyMac_PRECHECK(VideoMediaGetCodecParameter);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&O&",
CmpInstObj_Convert, &mh,
PyMac_GetOSType, &cType,
RGBColor rgbHiliteColor;
TimeValue duration;
TimeValue sampleTime;
+#ifndef TextMediaAddTextSample
+ PyMac_PRECHECK(TextMediaAddTextSample);
+#endif
if (!PyArg_ParseTuple(_args, "O&slhhbhllhhl",
CmpInstObj_Convert, &mh,
&text,
RGBColor rgbHiliteColor;
TimeValue duration;
TimeValue sampleTime;
+#ifndef TextMediaAddTESample
+ PyMac_PRECHECK(TextMediaAddTESample);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&hllhhl",
CmpInstObj_Convert, &mh,
ResObj_Convert, &hTE,
RGBColor rgbHiliteColor;
TimeValue duration;
TimeValue sampleTime;
+#ifndef TextMediaAddHiliteSample
+ PyMac_PRECHECK(TextMediaAddHiliteSample);
+#endif
if (!PyArg_ParseTuple(_args, "O&hhl",
CmpInstObj_Convert, &mh,
&hiliteStart,
void * data;
long dataSize;
TextDescriptionHandle tdh;
+#ifndef TextMediaDrawRaw
+ PyMac_PRECHECK(TextMediaDrawRaw);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&slO&",
CmpInstObj_Convert, &mh,
GWorldObj_Convert, &gw,
long propertyType;
void * data;
long dataSize;
+#ifndef TextMediaSetTextProperty
+ PyMac_PRECHECK(TextMediaSetTextProperty);
+#endif
if (!PyArg_ParseTuple(_args, "O&llsl",
CmpInstObj_Convert, &mh,
&atMediaTime,
long dataSize;
TextDescriptionHandle tdh;
TimeValue sampleDuration;
+#ifndef TextMediaRawSetup
+ PyMac_PRECHECK(TextMediaRawSetup);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&slO&l",
CmpInstObj_Convert, &mh,
GWorldObj_Convert, &gw,
TimeValue sampleTime;
long flagsIn;
long flagsOut;
+#ifndef TextMediaRawIdle
+ PyMac_PRECHECK(TextMediaRawIdle);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&ll",
CmpInstObj_Convert, &mh,
GWorldObj_Convert, &gw,
long propertyType;
void * data;
long dataSize;
+#ifndef TextMediaGetTextProperty
+ PyMac_PRECHECK(TextMediaGetTextProperty);
+#endif
if (!PyArg_ParseTuple(_args, "O&llsl",
CmpInstObj_Convert, &mh,
&atMediaTime,
TimeValue foundTime;
TimeValue foundDuration;
long offset;
+#ifndef TextMediaFindNextText
+ PyMac_PRECHECK(TextMediaFindNextText);
+#endif
if (!PyArg_ParseTuple(_args, "O&slhl",
CmpInstObj_Convert, &mh,
&text,
short hiliteStart;
short hiliteEnd;
RGBColor rgbHiliteColor;
+#ifndef TextMediaHiliteTextSample
+ PyMac_PRECHECK(TextMediaHiliteTextSample);
+#endif
if (!PyArg_ParseTuple(_args, "O&lhh",
CmpInstObj_Convert, &mh,
&sampleTime,
MediaHandler mh;
void * data;
OSType dataType;
+#ifndef TextMediaSetTextSampleData
+ PyMac_PRECHECK(TextMediaSetTextSampleData);
+#endif
if (!PyArg_ParseTuple(_args, "O&sO&",
CmpInstObj_Convert, &mh,
&data,
short spriteIndex;
long propertyType;
void * propertyValue;
+#ifndef SpriteMediaSetProperty
+ PyMac_PRECHECK(SpriteMediaSetProperty);
+#endif
if (!PyArg_ParseTuple(_args, "O&hls",
CmpInstObj_Convert, &mh,
&spriteIndex,
short spriteIndex;
long propertyType;
void * propertyValue;
+#ifndef SpriteMediaGetProperty
+ PyMac_PRECHECK(SpriteMediaGetProperty);
+#endif
if (!PyArg_ParseTuple(_args, "O&hls",
CmpInstObj_Convert, &mh,
&spriteIndex,
long flags;
Point loc;
short spriteHitIndex;
+#ifndef SpriteMediaHitTestSprites
+ PyMac_PRECHECK(SpriteMediaHitTestSprites);
+#endif
if (!PyArg_ParseTuple(_args, "O&lO&",
CmpInstObj_Convert, &mh,
&flags,
ComponentResult _rv;
MediaHandler mh;
short numSprites;
+#ifndef SpriteMediaCountSprites
+ PyMac_PRECHECK(SpriteMediaCountSprites);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CmpInstObj_Convert, &mh))
return NULL;
ComponentResult _rv;
MediaHandler mh;
short numImages;
+#ifndef SpriteMediaCountImages
+ PyMac_PRECHECK(SpriteMediaCountImages);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CmpInstObj_Convert, &mh))
return NULL;
MediaHandler mh;
short imageIndex;
ImageDescriptionHandle imageDescription;
+#ifndef SpriteMediaGetIndImageDescription
+ PyMac_PRECHECK(SpriteMediaGetIndImageDescription);
+#endif
if (!PyArg_ParseTuple(_args, "O&hO&",
CmpInstObj_Convert, &mh,
&imageIndex,
ComponentResult _rv;
MediaHandler mh;
long sampleNum;
+#ifndef SpriteMediaGetDisplayedSampleNumber
+ PyMac_PRECHECK(SpriteMediaGetDisplayedSampleNumber);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CmpInstObj_Convert, &mh))
return NULL;
MediaHandler mh;
QTAtomID spriteID;
Str255 spriteName;
+#ifndef SpriteMediaGetSpriteName
+ PyMac_PRECHECK(SpriteMediaGetSpriteName);
+#endif
if (!PyArg_ParseTuple(_args, "O&lO&",
CmpInstObj_Convert, &mh,
&spriteID,
MediaHandler mh;
short imageIndex;
Str255 imageName;
+#ifndef SpriteMediaGetImageName
+ PyMac_PRECHECK(SpriteMediaGetImageName);
+#endif
if (!PyArg_ParseTuple(_args, "O&hO&",
CmpInstObj_Convert, &mh,
&imageIndex,
QTAtomID spriteID;
long propertyType;
void * propertyValue;
+#ifndef SpriteMediaSetSpriteProperty
+ PyMac_PRECHECK(SpriteMediaSetSpriteProperty);
+#endif
if (!PyArg_ParseTuple(_args, "O&lls",
CmpInstObj_Convert, &mh,
&spriteID,
QTAtomID spriteID;
long propertyType;
void * propertyValue;
+#ifndef SpriteMediaGetSpriteProperty
+ PyMac_PRECHECK(SpriteMediaGetSpriteProperty);
+#endif
if (!PyArg_ParseTuple(_args, "O&lls",
CmpInstObj_Convert, &mh,
&spriteID,
long flags;
Point loc;
QTAtomID spriteHitID;
+#ifndef SpriteMediaHitTestAllSprites
+ PyMac_PRECHECK(SpriteMediaHitTestAllSprites);
+#endif
if (!PyArg_ParseTuple(_args, "O&lO&",
CmpInstObj_Convert, &mh,
&flags,
long flags;
Point loc;
Boolean wasHit;
+#ifndef SpriteMediaHitTestOneSprite
+ PyMac_PRECHECK(SpriteMediaHitTestOneSprite);
+#endif
if (!PyArg_ParseTuple(_args, "O&llO&",
CmpInstObj_Convert, &mh,
&spriteID,
MediaHandler mh;
short spriteIndex;
QTAtomID spriteID;
+#ifndef SpriteMediaSpriteIndexToID
+ PyMac_PRECHECK(SpriteMediaSpriteIndexToID);
+#endif
if (!PyArg_ParseTuple(_args, "O&h",
CmpInstObj_Convert, &mh,
&spriteIndex))
MediaHandler mh;
QTAtomID spriteID;
short spriteIndex;
+#ifndef SpriteMediaSpriteIDToIndex
+ PyMac_PRECHECK(SpriteMediaSpriteIDToIndex);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
CmpInstObj_Convert, &mh,
&spriteID))
MediaHandler mh;
QTAtomID variableID;
float value;
+#ifndef SpriteMediaSetActionVariable
+ PyMac_PRECHECK(SpriteMediaSetActionVariable);
+#endif
if (!PyArg_ParseTuple(_args, "O&lf",
CmpInstObj_Convert, &mh,
&variableID,
MediaHandler mh;
QTAtomID variableID;
float value;
+#ifndef SpriteMediaGetActionVariable
+ PyMac_PRECHECK(SpriteMediaGetActionVariable);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
CmpInstObj_Convert, &mh,
&variableID))
short imageIndex;
long imagePropertyType;
void * imagePropertyValue;
+#ifndef SpriteMediaGetIndImageProperty
+ PyMac_PRECHECK(SpriteMediaGetIndImageProperty);
+#endif
if (!PyArg_ParseTuple(_args, "O&hls",
CmpInstObj_Convert, &mh,
&imageIndex,
ComponentResult _rv;
MediaHandler mh;
QTAtomID spriteID;
+#ifndef SpriteMediaDisposeSprite
+ PyMac_PRECHECK(SpriteMediaDisposeSprite);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
CmpInstObj_Convert, &mh,
&spriteID))
MediaHandler mh;
QTAtomID variableID;
Ptr theCString;
+#ifndef SpriteMediaSetActionVariableToString
+ PyMac_PRECHECK(SpriteMediaSetActionVariableToString);
+#endif
if (!PyArg_ParseTuple(_args, "O&ls",
CmpInstObj_Convert, &mh,
&variableID,
MediaHandler mh;
QTAtomID variableID;
Handle theCString;
+#ifndef SpriteMediaGetActionVariableAsString
+ PyMac_PRECHECK(SpriteMediaGetActionVariableAsString);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
CmpInstObj_Convert, &mh,
&variableID))
MediaHandler mh;
short xPercent;
short yPercent;
+#ifndef FlashMediaSetPan
+ PyMac_PRECHECK(FlashMediaSetPan);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
CmpInstObj_Convert, &mh,
&xPercent,
ComponentResult _rv;
MediaHandler mh;
short factor;
+#ifndef FlashMediaSetZoom
+ PyMac_PRECHECK(FlashMediaSetZoom);
+#endif
if (!PyArg_ParseTuple(_args, "O&h",
CmpInstObj_Convert, &mh,
&factor))
long top;
long right;
long bottom;
+#ifndef FlashMediaSetZoomRect
+ PyMac_PRECHECK(FlashMediaSetZoomRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&llll",
CmpInstObj_Convert, &mh,
&left,
long top;
long right;
long bottom;
+#ifndef FlashMediaGetRefConBounds
+ PyMac_PRECHECK(FlashMediaGetRefConBounds);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
CmpInstObj_Convert, &mh,
&refCon))
MediaHandler mh;
long refCon;
long refConID;
+#ifndef FlashMediaGetRefConID
+ PyMac_PRECHECK(FlashMediaGetRefConID);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
CmpInstObj_Convert, &mh,
&refCon))
MediaHandler mh;
long refConID;
long refCon;
+#ifndef FlashMediaIDToRefCon
+ PyMac_PRECHECK(FlashMediaIDToRefCon);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
CmpInstObj_Convert, &mh,
&refConID))
ComponentResult _rv;
MediaHandler mh;
long flashFrameNumber;
+#ifndef FlashMediaGetDisplayedFrameNumber
+ PyMac_PRECHECK(FlashMediaGetDisplayedFrameNumber);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CmpInstObj_Convert, &mh))
return NULL;
MediaHandler mh;
long flashFrameNumber;
TimeValue movieTime;
+#ifndef FlashMediaFrameNumberToMovieTime
+ PyMac_PRECHECK(FlashMediaFrameNumberToMovieTime);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
CmpInstObj_Convert, &mh,
&flashFrameNumber))
MediaHandler mh;
Ptr theLabel;
TimeValue movieTime;
+#ifndef FlashMediaFrameLabelToMovieTime
+ PyMac_PRECHECK(FlashMediaFrameLabelToMovieTime);
+#endif
if (!PyArg_ParseTuple(_args, "O&s",
CmpInstObj_Convert, &mh,
&theLabel))
char path;
char name;
Handle theVariableCStringOut;
+#ifndef FlashMediaGetFlashVariable
+ PyMac_PRECHECK(FlashMediaGetFlashVariable);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CmpInstObj_Convert, &mh))
return NULL;
char name;
char value;
Boolean updateFocus;
+#ifndef FlashMediaSetFlashVariable
+ PyMac_PRECHECK(FlashMediaSetFlashVariable);
+#endif
if (!PyArg_ParseTuple(_args, "O&b",
CmpInstObj_Convert, &mh,
&updateFocus))
char path;
long buttonID;
long transition;
+#ifndef FlashMediaDoButtonActions
+ PyMac_PRECHECK(FlashMediaDoButtonActions);
+#endif
if (!PyArg_ParseTuple(_args, "O&ll",
CmpInstObj_Convert, &mh,
&buttonID,
ComponentResult _rv;
MediaHandler mh;
UInt8 swfVersion;
+#ifndef FlashMediaGetSupportedSwfVersion
+ PyMac_PRECHECK(FlashMediaGetSupportedSwfVersion);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CmpInstObj_Convert, &mh))
return NULL;
MediaHandler mh;
OSType whichProperty;
void * value;
+#ifndef MovieMediaGetCurrentMovieProperty
+ PyMac_PRECHECK(MovieMediaGetCurrentMovieProperty);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&s",
CmpInstObj_Convert, &mh,
PyMac_GetOSType, &whichProperty,
long trackID;
OSType whichProperty;
void * value;
+#ifndef MovieMediaGetCurrentTrackProperty
+ PyMac_PRECHECK(MovieMediaGetCurrentTrackProperty);
+#endif
if (!PyArg_ParseTuple(_args, "O&lO&s",
CmpInstObj_Convert, &mh,
&trackID,
Handle dataRef;
QTAtomID dataRefIDOut;
short dataRefIndexOut;
+#ifndef MovieMediaGetChildMovieDataReference
+ PyMac_PRECHECK(MovieMediaGetChildMovieDataReference);
+#endif
if (!PyArg_ParseTuple(_args, "O&lh",
CmpInstObj_Convert, &mh,
&dataRefID,
QTAtomID dataRefID;
OSType dataRefType;
Handle dataRef;
+#ifndef MovieMediaSetChildMovieDataReference
+ PyMac_PRECHECK(MovieMediaSetChildMovieDataReference);
+#endif
if (!PyArg_ParseTuple(_args, "O&lO&O&",
CmpInstObj_Convert, &mh,
&dataRefID,
ComponentResult _rv;
MediaHandler mh;
QTAtomID dataRefID;
+#ifndef MovieMediaLoadChildMovieFromDataReference
+ PyMac_PRECHECK(MovieMediaLoadChildMovieFromDataReference);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
CmpInstObj_Convert, &mh,
&dataRefID))
ComponentResult _rv;
MediaHandler mh;
void * group;
+#ifndef Media3DGetCurrentGroup
+ PyMac_PRECHECK(Media3DGetCurrentGroup);
+#endif
if (!PyArg_ParseTuple(_args, "O&s",
CmpInstObj_Convert, &mh,
&group))
Fixed x;
Fixed y;
Fixed z;
+#ifndef Media3DTranslateNamedObjectTo
+ PyMac_PRECHECK(Media3DTranslateNamedObjectTo);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&O&",
CmpInstObj_Convert, &mh,
PyMac_GetFixed, &x,
Fixed xScale;
Fixed yScale;
Fixed zScale;
+#ifndef Media3DScaleNamedObjectTo
+ PyMac_PRECHECK(Media3DScaleNamedObjectTo);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&O&",
CmpInstObj_Convert, &mh,
PyMac_GetFixed, &xScale,
Fixed xDegrees;
Fixed yDegrees;
Fixed zDegrees;
+#ifndef Media3DRotateNamedObjectTo
+ PyMac_PRECHECK(Media3DRotateNamedObjectTo);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&O&",
CmpInstObj_Convert, &mh,
PyMac_GetFixed, &xDegrees,
ComponentResult _rv;
MediaHandler mh;
void * cameraData;
+#ifndef Media3DSetCameraData
+ PyMac_PRECHECK(Media3DSetCameraData);
+#endif
if (!PyArg_ParseTuple(_args, "O&s",
CmpInstObj_Convert, &mh,
&cameraData))
ComponentResult _rv;
MediaHandler mh;
void * cameraData;
+#ifndef Media3DGetCameraData
+ PyMac_PRECHECK(Media3DGetCameraData);
+#endif
if (!PyArg_ParseTuple(_args, "O&s",
CmpInstObj_Convert, &mh,
&cameraData))
MediaHandler mh;
QTFloatSingle fov;
QTFloatSingle aspectRatioXToY;
+#ifndef Media3DSetCameraAngleAspect
+ PyMac_PRECHECK(Media3DSetCameraAngleAspect);
+#endif
if (!PyArg_ParseTuple(_args, "O&ff",
CmpInstObj_Convert, &mh,
&fov,
MediaHandler mh;
QTFloatSingle fov;
QTFloatSingle aspectRatioXToY;
+#ifndef Media3DGetCameraAngleAspect
+ PyMac_PRECHECK(Media3DGetCameraAngleAspect);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CmpInstObj_Convert, &mh))
return NULL;
ComponentResult _rv;
MediaHandler mh;
void * tQ3CameraRange;
+#ifndef Media3DSetCameraRange
+ PyMac_PRECHECK(Media3DSetCameraRange);
+#endif
if (!PyArg_ParseTuple(_args, "O&s",
CmpInstObj_Convert, &mh,
&tQ3CameraRange))
ComponentResult _rv;
MediaHandler mh;
void * tQ3CameraRange;
+#ifndef Media3DGetCameraRange
+ PyMac_PRECHECK(Media3DGetCameraRange);
+#endif
if (!PyArg_ParseTuple(_args, "O&s",
CmpInstObj_Convert, &mh,
&tQ3CameraRange))
ComponentResult _rv;
MediaHandler mh;
void * tq3viewObject;
+#ifndef Media3DGetViewObject
+ PyMac_PRECHECK(Media3DGetViewObject);
+#endif
if (!PyArg_ParseTuple(_args, "O&s",
CmpInstObj_Convert, &mh,
&tq3viewObject))
{
PyObject *_res = NULL;
TimeBase _rv;
+#ifndef NewTimeBase
+ PyMac_PRECHECK(NewTimeBase);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = NewTimeBase();
PyObject *_res = NULL;
TimeRecord theTime;
TimeBase newBase;
+#ifndef ConvertTime
+ PyMac_PRECHECK(ConvertTime);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
TimeBaseObj_Convert, &newBase))
return NULL;
PyObject *_res = NULL;
TimeRecord theTime;
TimeScale newScale;
+#ifndef ConvertTimeScale
+ PyMac_PRECHECK(ConvertTimeScale);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&newScale))
return NULL;
PyObject *_res = NULL;
TimeRecord dst;
TimeRecord src;
+#ifndef AddTime
+ PyMac_PRECHECK(AddTime);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
QtTimeRecord_Convert, &dst,
QtTimeRecord_Convert, &src))
PyObject *_res = NULL;
TimeRecord dst;
TimeRecord src;
+#ifndef SubtractTime
+ PyMac_PRECHECK(SubtractTime);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
QtTimeRecord_Convert, &dst,
QtTimeRecord_Convert, &src))
ComponentInstance ti;
long sampleDescIndex;
ComponentInstance tp;
+#ifndef MusicMediaGetIndexedTunePlayer
+ PyMac_PRECHECK(MusicMediaGetIndexedTunePlayer);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
CmpInstObj_Convert, &ti,
&sampleDescIndex))
PyObject *_res = NULL;
WindowPtr wp;
Boolean front;
+#ifndef AlignWindow
+ PyMac_PRECHECK(AlignWindow);
+#endif
if (!PyArg_ParseTuple(_args, "O&b",
WinObj_Convert, &wp,
&front))
WindowPtr wp;
Point startPt;
Rect boundsRect;
+#ifndef DragAlignedWindow
+ PyMac_PRECHECK(DragAlignedWindow);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
WinObj_Convert, &wp,
PyMac_GetPoint, &startPt,
{
PyObject *_res = NULL;
long maxMilliSecToUse;
+#ifndef MoviesTask
+ PyMac_PRECHECK(MoviesTask);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&maxMilliSecToUse))
return NULL;
char *text__in__;
long text__len__;
int text__in_len__;
+#ifndef TESetText
+ PyMac_PRECHECK(TESetText);
+#endif
if (!PyArg_ParseTuple(_args, "s#",
&text__in__, &text__in_len__))
return NULL;
{
PyObject *_res = NULL;
CharsHandle _rv;
+#ifndef TEGetText
+ PyMac_PRECHECK(TEGetText);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = TEGetText(_self->ob_itself);
static PyObject *TEObj_TEIdle(TEObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef TEIdle
+ PyMac_PRECHECK(TEIdle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TEIdle(_self->ob_itself);
PyObject *_res = NULL;
long selStart;
long selEnd;
+#ifndef TESetSelect
+ PyMac_PRECHECK(TESetSelect);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&selStart,
&selEnd))
static PyObject *TEObj_TEActivate(TEObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef TEActivate
+ PyMac_PRECHECK(TEActivate);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TEActivate(_self->ob_itself);
static PyObject *TEObj_TEDeactivate(TEObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef TEDeactivate
+ PyMac_PRECHECK(TEDeactivate);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TEDeactivate(_self->ob_itself);
{
PyObject *_res = NULL;
CharParameter key;
+#ifndef TEKey
+ PyMac_PRECHECK(TEKey);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&key))
return NULL;
static PyObject *TEObj_TECut(TEObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef TECut
+ PyMac_PRECHECK(TECut);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TECut(_self->ob_itself);
static PyObject *TEObj_TECopy(TEObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef TECopy
+ PyMac_PRECHECK(TECopy);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TECopy(_self->ob_itself);
static PyObject *TEObj_TEPaste(TEObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef TEPaste
+ PyMac_PRECHECK(TEPaste);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TEPaste(_self->ob_itself);
static PyObject *TEObj_TEDelete(TEObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef TEDelete
+ PyMac_PRECHECK(TEDelete);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TEDelete(_self->ob_itself);
char *text__in__;
long text__len__;
int text__in_len__;
+#ifndef TEInsert
+ PyMac_PRECHECK(TEInsert);
+#endif
if (!PyArg_ParseTuple(_args, "s#",
&text__in__, &text__in_len__))
return NULL;
{
PyObject *_res = NULL;
short just;
+#ifndef TESetAlignment
+ PyMac_PRECHECK(TESetAlignment);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&just))
return NULL;
{
PyObject *_res = NULL;
Rect rUpdate;
+#ifndef TEUpdate
+ PyMac_PRECHECK(TEUpdate);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &rUpdate))
return NULL;
PyObject *_res = NULL;
short dh;
short dv;
+#ifndef TEScroll
+ PyMac_PRECHECK(TEScroll);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&dh,
&dv))
static PyObject *TEObj_TESelView(TEObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef TESelView
+ PyMac_PRECHECK(TESelView);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TESelView(_self->ob_itself);
PyObject *_res = NULL;
short dh;
short dv;
+#ifndef TEPinScroll
+ PyMac_PRECHECK(TEPinScroll);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&dh,
&dv))
{
PyObject *_res = NULL;
Boolean fAuto;
+#ifndef TEAutoView
+ PyMac_PRECHECK(TEAutoView);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&fAuto))
return NULL;
static PyObject *TEObj_TECalText(TEObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef TECalText
+ PyMac_PRECHECK(TECalText);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TECalText(_self->ob_itself);
PyObject *_res = NULL;
short _rv;
Point pt;
+#ifndef TEGetOffset
+ PyMac_PRECHECK(TEGetOffset);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetPoint, &pt))
return NULL;
PyObject *_res = NULL;
Point _rv;
short offset;
+#ifndef TEGetPoint
+ PyMac_PRECHECK(TEGetPoint);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&offset))
return NULL;
PyObject *_res = NULL;
Point pt;
Boolean fExtend;
+#ifndef TEClick
+ PyMac_PRECHECK(TEClick);
+#endif
if (!PyArg_ParseTuple(_args, "O&b",
PyMac_GetPoint, &pt,
&fExtend))
{
PyObject *_res = NULL;
TEStyleHandle theHandle;
+#ifndef TESetStyleHandle
+ PyMac_PRECHECK(TESetStyleHandle);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &theHandle))
return NULL;
{
PyObject *_res = NULL;
TEStyleHandle _rv;
+#ifndef TEGetStyleHandle
+ PyMac_PRECHECK(TEGetStyleHandle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = TEGetStyleHandle(_self->ob_itself);
TextStyle theStyle;
short lineHeight;
short fontAscent;
+#ifndef TEGetStyle
+ PyMac_PRECHECK(TEGetStyle);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&offset))
return NULL;
static PyObject *TEObj_TEStylePaste(TEObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef TEStylePaste
+ PyMac_PRECHECK(TEStylePaste);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TEStylePaste(_self->ob_itself);
short mode;
TextStyle newStyle;
Boolean fRedraw;
+#ifndef TESetStyle
+ PyMac_PRECHECK(TESetStyle);
+#endif
if (!PyArg_ParseTuple(_args, "hO&b",
&mode,
TextStyle_Convert, &newStyle,
TextStyle oldStyle;
TextStyle newStyle;
Boolean fRedraw;
+#ifndef TEReplaceStyle
+ PyMac_PRECHECK(TEReplaceStyle);
+#endif
if (!PyArg_ParseTuple(_args, "hO&O&b",
&mode,
TextStyle_Convert, &oldStyle,
{
PyObject *_res = NULL;
StScrpHandle _rv;
+#ifndef TEGetStyleScrapHandle
+ PyMac_PRECHECK(TEGetStyleScrapHandle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = TEGetStyleScrapHandle(_self->ob_itself);
long text__len__;
int text__in_len__;
StScrpHandle hST;
+#ifndef TEStyleInsert
+ PyMac_PRECHECK(TEStyleInsert);
+#endif
if (!PyArg_ParseTuple(_args, "s#O&",
&text__in__, &text__in_len__,
ResObj_Convert, &hST))
long _rv;
long endLine;
long startLine;
+#ifndef TEGetHeight
+ PyMac_PRECHECK(TEGetHeight);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&endLine,
&startLine))
Boolean _rv;
short mode;
TextStyle aStyle;
+#ifndef TEContinuousStyle
+ PyMac_PRECHECK(TEContinuousStyle);
+#endif
if (!PyArg_ParseTuple(_args, "hO&",
&mode,
TextStyle_Convert, &aStyle))
long rangeEnd;
StScrpHandle newStyles;
Boolean fRedraw;
+#ifndef TEUseStyleScrap
+ PyMac_PRECHECK(TEUseStyleScrap);
+#endif
if (!PyArg_ParseTuple(_args, "llO&b",
&rangeStart,
&rangeEnd,
long _rv;
long rangeStart;
long rangeEnd;
+#ifndef TENumStyles
+ PyMac_PRECHECK(TENumStyles);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&rangeStart,
&rangeEnd))
short _rv;
short feature;
short action;
+#ifndef TEFeatureFlag
+ PyMac_PRECHECK(TEFeatureFlag);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&feature,
&action))
PyObject *_res = NULL;
OSErr _err;
RgnHandle region;
+#ifndef TEGetHiliteRgn
+ PyMac_PRECHECK(TEGetHiliteRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, ®ion))
return NULL;
{
PyObject *_res = NULL;
Handle _rv;
+#ifndef as_Resource
+ PyMac_PRECHECK(as_Resource);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = as_Resource(_self->ob_itself);
{
PyObject *_res = NULL;
Handle _rv;
+#ifndef TEScrapHandle
+ PyMac_PRECHECK(TEScrapHandle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = TEScrapHandle();
{
PyObject *_res = NULL;
long _rv;
+#ifndef TEGetScrapLength
+ PyMac_PRECHECK(TEGetScrapLength);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = TEGetScrapLength();
TEHandle _rv;
Rect destRect;
Rect viewRect;
+#ifndef TENew
+ PyMac_PRECHECK(TENew);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetRect, &destRect,
PyMac_GetRect, &viewRect))
int text__in_len__;
Rect box;
short just;
+#ifndef TETextBox
+ PyMac_PRECHECK(TETextBox);
+#endif
if (!PyArg_ParseTuple(_args, "s#O&h",
&text__in__, &text__in_len__,
PyMac_GetRect, &box,
TEHandle _rv;
Rect destRect;
Rect viewRect;
+#ifndef TEStyleNew
+ PyMac_PRECHECK(TEStyleNew);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetRect, &destRect,
PyMac_GetRect, &viewRect))
{
PyObject *_res = NULL;
long length;
+#ifndef TESetScrapLength
+ PyMac_PRECHECK(TESetScrapLength);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&length))
return NULL;
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef TEFromScrap
+ PyMac_PRECHECK(TEFromScrap);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = TEFromScrap();
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef TEToScrap
+ PyMac_PRECHECK(TEToScrap);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = TEToScrap();
{
PyObject *_res = NULL;
Handle _rv;
+#ifndef TEGetScrapHandle
+ PyMac_PRECHECK(TEGetScrapHandle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = TEGetScrapHandle();
{
PyObject *_res = NULL;
Handle value;
+#ifndef TESetScrapHandle
+ PyMac_PRECHECK(TESetScrapHandle);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &value))
return NULL;
{
PyObject *_res = NULL;
UInt8 _rv;
+#ifndef LMGetWordRedraw
+ PyMac_PRECHECK(LMGetWordRedraw);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = LMGetWordRedraw();
{
PyObject *_res = NULL;
UInt8 value;
+#ifndef LMSetWordRedraw
+ PyMac_PRECHECK(LMSetWordRedraw);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&value))
return NULL;
PyObject *_res = NULL;
TEHandle _rv;
Handle h;
+#ifndef as_TE
+ PyMac_PRECHECK(as_TE);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &h))
return NULL;
def writeinitialdefs(self):
self.defsfile.write("kPascalStackBased = None # workaround for header parsing\n")
+ self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n")
+
def makeblacklistnames(self):
return [
"WEDispose",
"WEVersion", # Unfortunately...
"WEPut", # XXXX TBD: needs array of flavortypes.
"WEGetOneAttribute", # XXXX TBD: output buffer
+ # Incompatible constant definitions
+ "weDoAutoScroll",
+ "weDoOutlineHilite",
+ "weDoReadOnly",
+ "weDoUndo",
+ "weDoIntCutAndPaste",
+ "weDoDragAndDrop",
+ "weDoInhibitRecal",
+ "weDoUseTempMem",
+ "weDoDrawOffscreen",
+ "weDoInhibitRedraw",
+ "weDoMonoStyled",
+ "weDoMultipleUndo",
+ "weDoNoKeyboardSync",
+ "weDoInhibitICSupport",
+ "weDoInhibitColor",
]
def makeblacklisttypes(self):
def writeinitialdefs(self):
self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n")
+ self.defsfile.write("false = 0\n")
+ self.defsfile.write("true = 1\n")
def makeblacklistnames(self):
return [