}
#endif
-static PyObject *AEDesc_AESend(AEDescObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- AppleEvent reply;
- AESendMode sendMode;
- AESendPriority sendPriority;
- long timeOutInTicks;
- if (!PyArg_ParseTuple(_args, "lhl",
- &sendMode,
- &sendPriority,
- &timeOutInTicks))
- return NULL;
- _err = AESend(&_self->ob_itself,
- &reply,
- sendMode,
- sendPriority,
- timeOutInTicks,
- upp_AEIdleProc,
- (AEFilterUPP)0);
- if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("O&",
- AEDesc_New, &reply);
- return _res;
-}
-
-static PyObject *AEDesc_AEResetTimer(AEDescObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- if (!PyArg_ParseTuple(_args, ""))
- return NULL;
- _err = AEResetTimer(&_self->ob_itself);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
-static PyObject *AEDesc_AESuspendTheCurrentEvent(AEDescObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- if (!PyArg_ParseTuple(_args, ""))
- return NULL;
- _err = AESuspendTheCurrentEvent(&_self->ob_itself);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
-static PyObject *AEDesc_AEResumeTheCurrentEvent(AEDescObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- AppleEvent reply;
- AEEventHandlerUPP dispatcher__proc__ = upp_GenericEventHandler;
- PyObject *dispatcher;
- if (!PyArg_ParseTuple(_args, "O&O",
- AEDesc_Convert, &reply,
- &dispatcher))
- return NULL;
- _err = AEResumeTheCurrentEvent(&_self->ob_itself,
- &reply,
- dispatcher__proc__, (long)dispatcher);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- Py_INCREF(dispatcher); /* XXX leak, but needed */
- return _res;
-}
-
-static PyObject *AEDesc_AEGetTheCurrentEvent(AEDescObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- if (!PyArg_ParseTuple(_args, ""))
- return NULL;
- _err = AEGetTheCurrentEvent(&_self->ob_itself);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
-static PyObject *AEDesc_AESetTheCurrentEvent(AEDescObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- if (!PyArg_ParseTuple(_args, ""))
- return NULL;
- _err = AESetTheCurrentEvent(&_self->ob_itself);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
static PyObject *AEDesc_AEResolve(AEDescObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
{"AEGetDescDataSize", (PyCFunction)AEDesc_AEGetDescDataSize, 1,
"() -> (Size _rv)"},
#endif
- {"AESend", (PyCFunction)AEDesc_AESend, 1,
- "(AESendMode sendMode, AESendPriority sendPriority, long timeOutInTicks) -> (AppleEvent reply)"},
- {"AEResetTimer", (PyCFunction)AEDesc_AEResetTimer, 1,
- "() -> None"},
- {"AESuspendTheCurrentEvent", (PyCFunction)AEDesc_AESuspendTheCurrentEvent, 1,
- "() -> None"},
- {"AEResumeTheCurrentEvent", (PyCFunction)AEDesc_AEResumeTheCurrentEvent, 1,
- "(AppleEvent reply, EventHandler dispatcher) -> None"},
- {"AEGetTheCurrentEvent", (PyCFunction)AEDesc_AEGetTheCurrentEvent, 1,
- "() -> None"},
- {"AESetTheCurrentEvent", (PyCFunction)AEDesc_AESetTheCurrentEvent, 1,
- "() -> None"},
{"AEResolve", (PyCFunction)AEDesc_AEResolve, 1,
"(short callbackFlags) -> (AEDesc theToken)"},
{NULL, NULL, 0}
}
#endif
-static PyObject *AE_AEProcessAppleEvent(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- EventRecord theEventRecord;
- if (!PyArg_ParseTuple(_args, "O&",
- PyMac_GetEventRecord, &theEventRecord))
- return NULL;
- _err = AEProcessAppleEvent(&theEventRecord);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
-static PyObject *AE_AEGetInteractionAllowed(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- AEInteractAllowed level;
- if (!PyArg_ParseTuple(_args, ""))
- return NULL;
- _err = AEGetInteractionAllowed(&level);
- if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("b",
- level);
- return _res;
-}
-
-static PyObject *AE_AESetInteractionAllowed(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- AEInteractAllowed level;
- if (!PyArg_ParseTuple(_args, "b",
- &level))
- return NULL;
- _err = AESetInteractionAllowed(level);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
-static PyObject *AE_AEInteractWithUser(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- OSErr _err;
- long timeOutInTicks;
- if (!PyArg_ParseTuple(_args, "l",
- &timeOutInTicks))
- return NULL;
- _err = AEInteractWithUser(timeOutInTicks,
- (NMRecPtr)0,
- upp_AEIdleProc);
- if (_err != noErr) return PyMac_Error(_err);
- Py_INCREF(Py_None);
- _res = Py_None;
- return _res;
-}
-
static PyObject *AE_AEInstallEventHandler(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
{"AEReplaceDescData", (PyCFunction)AE_AEReplaceDescData, 1,
"(DescType typeCode, Buffer dataPtr) -> (AEDesc theAEDesc)"},
#endif
- {"AEProcessAppleEvent", (PyCFunction)AE_AEProcessAppleEvent, 1,
- "(EventRecord theEventRecord) -> None"},
- {"AEGetInteractionAllowed", (PyCFunction)AE_AEGetInteractionAllowed, 1,
- "() -> (AEInteractAllowed level)"},
- {"AESetInteractionAllowed", (PyCFunction)AE_AESetInteractionAllowed, 1,
- "(AEInteractAllowed level) -> None"},
- {"AEInteractWithUser", (PyCFunction)AE_AEInteractWithUser, 1,
- "(long timeOutInTicks) -> None"},
{"AEInstallEventHandler", (PyCFunction)AE_AEInstallEventHandler, 1,
"(AEEventClass theAEEventClass, AEEventID theAEEventID, EventHandler handler) -> None"},
{"AERemoveEventHandler", (PyCFunction)AE_AERemoveEventHandler, 1,
return _res;
}
+#if TARGET_API_MAC_CARBON
+
+static PyObject *App_TruncateThemeText(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ CFMutableStringRef inString;
+ ThemeFontID inFontID;
+ ThemeDrawState inState;
+ SInt16 inPixelWidthLimit;
+ TruncCode inTruncWhere;
+ Boolean outTruncated;
+ if (!PyArg_ParseTuple(_args, "O&Hlhh",
+ CFMutableStringRefObj_Convert, &inString,
+ &inFontID,
+ &inState,
+ &inPixelWidthLimit,
+ &inTruncWhere))
+ return NULL;
+ _err = TruncateThemeText(inString,
+ inFontID,
+ inState,
+ inPixelWidthLimit,
+ inTruncWhere,
+ &outTruncated);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("b",
+ outTruncated);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *App_GetThemeTextDimensions(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ CFStringRef inString;
+ ThemeFontID inFontID;
+ ThemeDrawState inState;
+ Boolean inWrapToWidth;
+ Point ioBounds;
+ SInt16 outBaseline;
+ if (!PyArg_ParseTuple(_args, "O&Hlb",
+ CFStringRefObj_Convert, &inString,
+ &inFontID,
+ &inState,
+ &inWrapToWidth))
+ return NULL;
+ _err = GetThemeTextDimensions(inString,
+ inFontID,
+ inState,
+ inWrapToWidth,
+ &ioBounds,
+ &outBaseline);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&h",
+ PyMac_BuildPoint, ioBounds,
+ outBaseline);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *App_GetThemeTextShadowOutset(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ ThemeFontID inFontID;
+ ThemeDrawState inState;
+ Rect outOutset;
+ if (!PyArg_ParseTuple(_args, "Hl",
+ &inFontID,
+ &inState))
+ return NULL;
+ _err = GetThemeTextShadowOutset(inFontID,
+ inState,
+ &outOutset);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ PyMac_BuildRect, &outOutset);
+ return _res;
+}
+#endif
+
static PyObject *App_DrawThemeScrollBarArrows(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
"() -> (ThemeCheckBoxStyle outStyle)"},
{"UseThemeFont", (PyCFunction)App_UseThemeFont, 1,
"(ThemeFontID inFontID, ScriptCode inScript) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"TruncateThemeText", (PyCFunction)App_TruncateThemeText, 1,
+ "(CFMutableStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, SInt16 inPixelWidthLimit, TruncCode inTruncWhere) -> (Boolean outTruncated)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetThemeTextDimensions", (PyCFunction)App_GetThemeTextDimensions, 1,
+ "(CFStringRef inString, ThemeFontID inFontID, ThemeDrawState inState, Boolean inWrapToWidth) -> (Point ioBounds, SInt16 outBaseline)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetThemeTextShadowOutset", (PyCFunction)App_GetThemeTextShadowOutset, 1,
+ "(ThemeFontID inFontID, ThemeDrawState inState) -> (Rect outOutset)"},
+#endif
{"DrawThemeScrollBarArrows", (PyCFunction)App_DrawThemeScrollBarArrows, 1,
"(Rect bounds, ThemeTrackEnableState enableState, ThemeTrackPressState pressState, Boolean isHoriz) -> (Rect trackBounds)"},
{"GetThemeScrollBarTrackRect", (PyCFunction)App_GetThemeScrollBarTrackRect, 1,
"appearanceBadTextColorIndexErr",
"appearanceThemeHasNoAccents",
"appearanceBadCursorIndexErr",
+ "DrawThemeTextBox", # Funny void* out param
]
def makegreylist(self):
return [
('#if TARGET_API_MAC_CARBON', [
'GetThemeMetric',
+ 'GetThemeTextShadowOutset',
+ 'GetThemeTextDimensions',
+ 'TruncateThemeText',
])]
def makeblacklisttypes(self):
"ThemeWindowMetrics_ptr", # ditto
"ThemeDrawingState", # This is an opaque pointer, so it should be simple. Later.
"Collection", # No interface to collection mgr yet.
+ "BytePtr", # Not yet.
]
def makerepairinstructions(self):
ThemeBackgroundKind = Type("ThemeBackgroundKind", "l")
ThemeMetric = Type("ThemeMetric", "l")
RGBColor = OpaqueType("RGBColor", "QdRGB")
+CFStringRef = OpaqueByValueType("CFStringRef", "CFStringRefObj")
+CFMutableStringRef = OpaqueByValueType("CFMutableStringRef", "CFMutableStringRefObj")
+TruncCode = Type("TruncCode", "h")
includestuff = includestuff + """
#ifdef WITHOUT_FRAMEWORKS
return _res;
}
+static PyObject *CFMutableArrayRefObj_CFArrayAppendArray(CFMutableArrayRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFArrayRef otherArray;
+ CFRange otherRange;
+#ifndef CFArrayAppendArray
+ PyMac_PRECHECK(CFArrayAppendArray);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&O&",
+ CFArrayRefObj_Convert, &otherArray,
+ CFRange_Convert, &otherRange))
+ return NULL;
+ CFArrayAppendArray(_self->ob_itself,
+ otherArray,
+ otherRange);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyMethodDef CFMutableArrayRefObj_methods[] = {
{"CFArrayRemoveValueAtIndex", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveValueAtIndex, 1,
"(CFIndex idx) -> None"},
"() -> None"},
{"CFArrayExchangeValuesAtIndices", (PyCFunction)CFMutableArrayRefObj_CFArrayExchangeValuesAtIndices, 1,
"(CFIndex idx1, CFIndex idx2) -> None"},
+ {"CFArrayAppendArray", (PyCFunction)CFMutableArrayRefObj_CFArrayAppendArray, 1,
+ "(CFArrayRef otherArray, CFRange otherRange) -> None"},
{NULL, NULL, 0}
};
{
PyObject *_res = NULL;
CFComparisonResult _rv;
- CFStringRef string2;
+ CFStringRef theString2;
CFRange rangeToCompare;
CFOptionFlags compareOptions;
#ifndef CFStringCompareWithOptions
PyMac_PRECHECK(CFStringCompareWithOptions);
#endif
if (!PyArg_ParseTuple(_args, "O&O&l",
- CFStringRefObj_Convert, &string2,
+ CFStringRefObj_Convert, &theString2,
CFRange_Convert, &rangeToCompare,
&compareOptions))
return NULL;
_rv = CFStringCompareWithOptions(_self->ob_itself,
- string2,
+ theString2,
rangeToCompare,
compareOptions);
_res = Py_BuildValue("l",
{
PyObject *_res = NULL;
CFComparisonResult _rv;
- CFStringRef string2;
+ CFStringRef theString2;
CFOptionFlags compareOptions;
#ifndef CFStringCompare
PyMac_PRECHECK(CFStringCompare);
#endif
if (!PyArg_ParseTuple(_args, "O&l",
- CFStringRefObj_Convert, &string2,
+ CFStringRefObj_Convert, &theString2,
&compareOptions))
return NULL;
_rv = CFStringCompare(_self->ob_itself,
- string2,
+ theString2,
compareOptions);
_res = Py_BuildValue("l",
_rv);
return _res;
}
+static PyObject *CFStringRefObj_CFURLCreateWithFileSystemPathRelativeToBase(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFURLRef _rv;
+ CFURLPathStyle pathStyle;
+ Boolean isDirectory;
+ CFURLRef baseURL;
+ if (!PyArg_ParseTuple(_args, "llO&",
+ &pathStyle,
+ &isDirectory,
+ OptionalCFURLRefObj_Convert, &baseURL))
+ return NULL;
+ _rv = CFURLCreateWithFileSystemPathRelativeToBase((CFAllocatorRef)NULL,
+ _self->ob_itself,
+ pathStyle,
+ isDirectory,
+ baseURL);
+ _res = Py_BuildValue("O&",
+ CFURLRefObj_New, _rv);
+ return _res;
+}
+
static PyObject *CFStringRefObj_CFURLCreateStringByReplacingPercentEscapes(CFStringRefObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+static PyObject *CFStringRefObj_CFURLCreateStringByAddingPercentEscapes(CFStringRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ CFStringRef charactersToLeaveUnescaped;
+ CFStringRef legalURLCharactersToBeEscaped;
+ CFStringEncoding encoding;
+ if (!PyArg_ParseTuple(_args, "O&O&l",
+ CFStringRefObj_Convert, &charactersToLeaveUnescaped,
+ CFStringRefObj_Convert, &legalURLCharactersToBeEscaped,
+ &encoding))
+ return NULL;
+ _rv = CFURLCreateStringByAddingPercentEscapes((CFAllocatorRef)NULL,
+ _self->ob_itself,
+ charactersToLeaveUnescaped,
+ legalURLCharactersToBeEscaped,
+ encoding);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
static PyObject *CFStringRefObj_CFStringGetString(CFStringRefObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
{"CFStringGetFastestEncoding", (PyCFunction)CFStringRefObj_CFStringGetFastestEncoding, 1,
"() -> (CFStringEncoding _rv)"},
{"CFStringCompareWithOptions", (PyCFunction)CFStringRefObj_CFStringCompareWithOptions, 1,
- "(CFStringRef string2, CFRange rangeToCompare, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)"},
+ "(CFStringRef theString2, CFRange rangeToCompare, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)"},
{"CFStringCompare", (PyCFunction)CFStringRefObj_CFStringCompare, 1,
- "(CFStringRef string2, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)"},
+ "(CFStringRef theString2, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)"},
{"CFStringFindWithOptions", (PyCFunction)CFStringRefObj_CFStringFindWithOptions, 1,
"(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags searchOptions) -> (Boolean _rv, CFRange result)"},
{"CFStringCreateArrayWithFindResults", (PyCFunction)CFStringRefObj_CFStringCreateArrayWithFindResults, 1,
"(CFURLRef baseURL) -> (CFURLRef _rv)"},
{"CFURLCreateWithFileSystemPath", (PyCFunction)CFStringRefObj_CFURLCreateWithFileSystemPath, 1,
"(CFURLPathStyle pathStyle, Boolean isDirectory) -> (CFURLRef _rv)"},
+ {"CFURLCreateWithFileSystemPathRelativeToBase", (PyCFunction)CFStringRefObj_CFURLCreateWithFileSystemPathRelativeToBase, 1,
+ "(CFURLPathStyle pathStyle, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)"},
{"CFURLCreateStringByReplacingPercentEscapes", (PyCFunction)CFStringRefObj_CFURLCreateStringByReplacingPercentEscapes, 1,
"(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"},
+ {"CFURLCreateStringByAddingPercentEscapes", (PyCFunction)CFStringRefObj_CFURLCreateStringByAddingPercentEscapes, 1,
+ "(CFStringRef charactersToLeaveUnescaped, CFStringRef legalURLCharactersToBeEscaped, CFStringEncoding encoding) -> (CFStringRef _rv)"},
{"CFStringGetString", (PyCFunction)CFStringRefObj_CFStringGetString, 1,
"() -> (string _rv)"},
{"CFStringGetUnicode", (PyCFunction)CFStringRefObj_CFStringGetUnicode, 1,
static PyObject *CFMutableStringRefObj_CFStringAppendPascalString(CFMutableStringRefObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
- StringPtr pStr;
+ Str255 pStr;
CFStringEncoding encoding;
#ifndef CFStringAppendPascalString
PyMac_PRECHECK(CFStringAppendPascalString);
#endif
if (!PyArg_ParseTuple(_args, "O&l",
- PyMac_GetStr255, &pStr,
+ PyMac_GetStr255, pStr,
&encoding))
return NULL;
CFStringAppendPascalString(_self->ob_itself,
{"CFStringAppend", (PyCFunction)CFMutableStringRefObj_CFStringAppend, 1,
"(CFStringRef appendedString) -> None"},
{"CFStringAppendPascalString", (PyCFunction)CFMutableStringRefObj_CFStringAppendPascalString, 1,
- "(StringPtr pStr, CFStringEncoding encoding) -> None"},
+ "(Str255 pStr, CFStringEncoding encoding) -> None"},
{"CFStringAppendCString", (PyCFunction)CFMutableStringRefObj_CFStringAppendCString, 1,
"(char* cStr, CFStringEncoding encoding) -> None"},
{"CFStringInsert", (PyCFunction)CFMutableStringRefObj_CFStringInsert, 1,
return _res;
}
+static PyObject *CFURLRefObj_CFURLGetFileSystemRepresentation(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ Boolean resolveAgainstBase;
+ UInt8 buffer;
+ CFIndex maxBufLen;
+#ifndef CFURLGetFileSystemRepresentation
+ PyMac_PRECHECK(CFURLGetFileSystemRepresentation);
+#endif
+ if (!PyArg_ParseTuple(_args, "ll",
+ &resolveAgainstBase,
+ &maxBufLen))
+ return NULL;
+ _rv = CFURLGetFileSystemRepresentation(_self->ob_itself,
+ resolveAgainstBase,
+ &buffer,
+ maxBufLen);
+ _res = Py_BuildValue("lb",
+ _rv,
+ buffer);
+ return _res;
+}
+
static PyObject *CFURLRefObj_CFURLCopyAbsoluteURL(CFURLRefObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+static PyObject *CFURLRefObj_CFURLCopyStrictPath(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ Boolean isAbsolute;
+#ifndef CFURLCopyStrictPath
+ PyMac_PRECHECK(CFURLCopyStrictPath);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLCopyStrictPath(_self->ob_itself,
+ &isAbsolute);
+ _res = Py_BuildValue("O&l",
+ CFStringRefObj_New, _rv,
+ isAbsolute);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLCopyFileSystemPath(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+ CFURLPathStyle pathStyle;
+#ifndef CFURLCopyFileSystemPath
+ PyMac_PRECHECK(CFURLCopyFileSystemPath);
+#endif
+ if (!PyArg_ParseTuple(_args, "l",
+ &pathStyle))
+ return NULL;
+ _rv = CFURLCopyFileSystemPath(_self->ob_itself,
+ pathStyle);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
static PyObject *CFURLRefObj_CFURLHasDirectoryPath(CFURLRefObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+static PyObject *CFURLRefObj_CFURLCopyLastPathComponent(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+#ifndef CFURLCopyLastPathComponent
+ PyMac_PRECHECK(CFURLCopyLastPathComponent);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLCopyLastPathComponent(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLCopyPathExtension(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringRef _rv;
+#ifndef CFURLCopyPathExtension
+ PyMac_PRECHECK(CFURLCopyPathExtension);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLCopyPathExtension(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLCreateCopyAppendingPathComponent(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFURLRef _rv;
+ CFStringRef pathComponent;
+ Boolean isDirectory;
+ if (!PyArg_ParseTuple(_args, "O&l",
+ CFStringRefObj_Convert, &pathComponent,
+ &isDirectory))
+ return NULL;
+ _rv = CFURLCreateCopyAppendingPathComponent((CFAllocatorRef)NULL,
+ _self->ob_itself,
+ pathComponent,
+ isDirectory);
+ _res = Py_BuildValue("O&",
+ CFURLRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLCreateCopyDeletingLastPathComponent(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFURLRef _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLCreateCopyDeletingLastPathComponent((CFAllocatorRef)NULL,
+ _self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFURLRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLCreateCopyAppendingPathExtension(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFURLRef _rv;
+ CFStringRef extension;
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFStringRefObj_Convert, &extension))
+ return NULL;
+ _rv = CFURLCreateCopyAppendingPathExtension((CFAllocatorRef)NULL,
+ _self->ob_itself,
+ extension);
+ _res = Py_BuildValue("O&",
+ CFURLRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLCreateCopyDeletingPathExtension(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFURLRef _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLCreateCopyDeletingPathExtension((CFAllocatorRef)NULL,
+ _self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CFURLRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CFURLRefObj_CFURLGetFSRef(CFURLRefObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ FSRef fsRef;
+#ifndef CFURLGetFSRef
+ PyMac_PRECHECK(CFURLGetFSRef);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = CFURLGetFSRef(_self->ob_itself,
+ &fsRef);
+ _res = Py_BuildValue("lO&",
+ _rv,
+ PyMac_BuildFSRef, fsRef);
+ return _res;
+}
+
static PyMethodDef CFURLRefObj_methods[] = {
{"CFURLCreateData", (PyCFunction)CFURLRefObj_CFURLCreateData, 1,
"(CFStringEncoding encoding, Boolean escapeWhitespace) -> (CFDataRef _rv)"},
+ {"CFURLGetFileSystemRepresentation", (PyCFunction)CFURLRefObj_CFURLGetFileSystemRepresentation, 1,
+ "(Boolean resolveAgainstBase, CFIndex maxBufLen) -> (Boolean _rv, UInt8 buffer)"},
{"CFURLCopyAbsoluteURL", (PyCFunction)CFURLRefObj_CFURLCopyAbsoluteURL, 1,
"() -> (CFURLRef _rv)"},
{"CFURLGetString", (PyCFunction)CFURLRefObj_CFURLGetString, 1,
"() -> (CFStringRef _rv)"},
{"CFURLCopyPath", (PyCFunction)CFURLRefObj_CFURLCopyPath, 1,
"() -> (CFStringRef _rv)"},
+ {"CFURLCopyStrictPath", (PyCFunction)CFURLRefObj_CFURLCopyStrictPath, 1,
+ "() -> (CFStringRef _rv, Boolean isAbsolute)"},
+ {"CFURLCopyFileSystemPath", (PyCFunction)CFURLRefObj_CFURLCopyFileSystemPath, 1,
+ "(CFURLPathStyle pathStyle) -> (CFStringRef _rv)"},
{"CFURLHasDirectoryPath", (PyCFunction)CFURLRefObj_CFURLHasDirectoryPath, 1,
"() -> (Boolean _rv)"},
{"CFURLCopyResourceSpecifier", (PyCFunction)CFURLRefObj_CFURLCopyResourceSpecifier, 1,
"(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"},
{"CFURLCopyFragment", (PyCFunction)CFURLRefObj_CFURLCopyFragment, 1,
"(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)"},
+ {"CFURLCopyLastPathComponent", (PyCFunction)CFURLRefObj_CFURLCopyLastPathComponent, 1,
+ "() -> (CFStringRef _rv)"},
+ {"CFURLCopyPathExtension", (PyCFunction)CFURLRefObj_CFURLCopyPathExtension, 1,
+ "() -> (CFStringRef _rv)"},
+ {"CFURLCreateCopyAppendingPathComponent", (PyCFunction)CFURLRefObj_CFURLCreateCopyAppendingPathComponent, 1,
+ "(CFStringRef pathComponent, Boolean isDirectory) -> (CFURLRef _rv)"},
+ {"CFURLCreateCopyDeletingLastPathComponent", (PyCFunction)CFURLRefObj_CFURLCreateCopyDeletingLastPathComponent, 1,
+ "() -> (CFURLRef _rv)"},
+ {"CFURLCreateCopyAppendingPathExtension", (PyCFunction)CFURLRefObj_CFURLCreateCopyAppendingPathExtension, 1,
+ "(CFStringRef extension) -> (CFURLRef _rv)"},
+ {"CFURLCreateCopyDeletingPathExtension", (PyCFunction)CFURLRefObj_CFURLCreateCopyDeletingPathExtension, 1,
+ "() -> (CFURLRef _rv)"},
+ {"CFURLGetFSRef", (PyCFunction)CFURLRefObj_CFURLGetFSRef, 1,
+ "() -> (Boolean _rv, FSRef fsRef)"},
{NULL, NULL, 0}
};
/* -------------------- End object type CFURLRef -------------------- */
+static PyObject *CF___CFRangeMake(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFRange _rv;
+ CFIndex loc;
+ CFIndex len;
+#ifndef __CFRangeMake
+ PyMac_PRECHECK(__CFRangeMake);
+#endif
+ if (!PyArg_ParseTuple(_args, "ll",
+ &loc,
+ &len))
+ return NULL;
+ _rv = __CFRangeMake(loc,
+ len);
+ _res = Py_BuildValue("O&",
+ CFRange_New, _rv);
+ return _res;
+}
+
static PyObject *CF_CFAllocatorGetTypeID(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
{
PyObject *_res = NULL;
CFStringRef _rv;
- CFTypeID theType;
+ CFTypeID type_id;
#ifndef CFCopyTypeIDDescription
PyMac_PRECHECK(CFCopyTypeIDDescription);
#endif
if (!PyArg_ParseTuple(_args, "l",
- &theType))
+ &type_id))
return NULL;
- _rv = CFCopyTypeIDDescription(theType);
+ _rv = CFCopyTypeIDDescription(type_id);
_res = Py_BuildValue("O&",
CFStringRefObj_New, _rv);
return _res;
PyObject *_res = NULL;
CFMutableArrayRef _rv;
CFIndex capacity;
- CFArrayRef srcArray;
+ CFArrayRef theArray;
#ifndef CFArrayCreateMutableCopy
PyMac_PRECHECK(CFArrayCreateMutableCopy);
#endif
if (!PyArg_ParseTuple(_args, "lO&",
&capacity,
- CFArrayRefObj_Convert, &srcArray))
+ CFArrayRefObj_Convert, &theArray))
return NULL;
_rv = CFArrayCreateMutableCopy((CFAllocatorRef)NULL,
capacity,
- srcArray);
+ theArray);
_res = Py_BuildValue("O&",
CFMutableArrayRefObj_New, _rv);
return _res;
PyObject *_res = NULL;
CFMutableDataRef _rv;
CFIndex capacity;
- CFDataRef data;
+ CFDataRef theData;
#ifndef CFDataCreateMutableCopy
PyMac_PRECHECK(CFDataCreateMutableCopy);
#endif
if (!PyArg_ParseTuple(_args, "lO&",
&capacity,
- CFDataRefObj_Convert, &data))
+ CFDataRefObj_Convert, &theData))
return NULL;
_rv = CFDataCreateMutableCopy((CFAllocatorRef)NULL,
capacity,
- data);
+ theData);
_res = Py_BuildValue("O&",
CFMutableDataRefObj_New, _rv);
return _res;
PyObject *_res = NULL;
CFMutableDictionaryRef _rv;
CFIndex capacity;
- CFDictionaryRef dict;
+ CFDictionaryRef theDict;
#ifndef CFDictionaryCreateMutableCopy
PyMac_PRECHECK(CFDictionaryCreateMutableCopy);
#endif
if (!PyArg_ParseTuple(_args, "lO&",
&capacity,
- CFDictionaryRefObj_Convert, &dict))
+ CFDictionaryRefObj_Convert, &theDict))
return NULL;
_rv = CFDictionaryCreateMutableCopy((CFAllocatorRef)NULL,
capacity,
- dict);
+ theDict);
_res = Py_BuildValue("O&",
CFMutableDictionaryRefObj_New, _rv);
return _res;
{
PyObject *_res = NULL;
CFStringRef _rv;
- StringPtr pStr;
+ Str255 pStr;
CFStringEncoding encoding;
#ifndef CFStringCreateWithPascalString
PyMac_PRECHECK(CFStringCreateWithPascalString);
#endif
if (!PyArg_ParseTuple(_args, "O&l",
- PyMac_GetStr255, &pStr,
+ PyMac_GetStr255, pStr,
&encoding))
return NULL;
_rv = CFStringCreateWithPascalString((CFAllocatorRef)NULL,
{
PyObject *_res = NULL;
CFStringRef _rv;
- StringPtr pStr;
+ Str255 pStr;
CFStringEncoding encoding;
#ifndef CFStringCreateWithPascalStringNoCopy
PyMac_PRECHECK(CFStringCreateWithPascalStringNoCopy);
#endif
if (!PyArg_ParseTuple(_args, "O&l",
- PyMac_GetStr255, &pStr,
+ PyMac_GetStr255, pStr,
&encoding))
return NULL;
_rv = CFStringCreateWithPascalStringNoCopy((CFAllocatorRef)NULL,
return _res;
}
+static PyObject *CF_CFStringGetMostCompatibleMacStringEncoding(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFStringEncoding _rv;
+ CFStringEncoding encoding;
+#ifndef CFStringGetMostCompatibleMacStringEncoding
+ PyMac_PRECHECK(CFStringGetMostCompatibleMacStringEncoding);
+#endif
+ if (!PyArg_ParseTuple(_args, "l",
+ &encoding))
+ return NULL;
+ _rv = CFStringGetMostCompatibleMacStringEncoding(encoding);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+
static PyObject *CF___CFStringMakeConstantString(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+static PyObject *CF_CFURLCreateFromFileSystemRepresentation(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFURLRef _rv;
+ unsigned char *buffer__in__;
+ long buffer__len__;
+ int buffer__in_len__;
+ Boolean isDirectory;
+#ifndef CFURLCreateFromFileSystemRepresentation
+ PyMac_PRECHECK(CFURLCreateFromFileSystemRepresentation);
+#endif
+ if (!PyArg_ParseTuple(_args, "s#l",
+ &buffer__in__, &buffer__in_len__,
+ &isDirectory))
+ return NULL;
+ buffer__len__ = buffer__in_len__;
+ _rv = CFURLCreateFromFileSystemRepresentation((CFAllocatorRef)NULL,
+ buffer__in__, buffer__len__,
+ isDirectory);
+ _res = Py_BuildValue("O&",
+ CFURLRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CF_CFURLCreateFromFileSystemRepresentationRelativeToBase(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFURLRef _rv;
+ unsigned char *buffer__in__;
+ long buffer__len__;
+ int buffer__in_len__;
+ Boolean isDirectory;
+ CFURLRef baseURL;
+#ifndef CFURLCreateFromFileSystemRepresentationRelativeToBase
+ PyMac_PRECHECK(CFURLCreateFromFileSystemRepresentationRelativeToBase);
+#endif
+ if (!PyArg_ParseTuple(_args, "s#lO&",
+ &buffer__in__, &buffer__in_len__,
+ &isDirectory,
+ OptionalCFURLRefObj_Convert, &baseURL))
+ return NULL;
+ buffer__len__ = buffer__in_len__;
+ _rv = CFURLCreateFromFileSystemRepresentationRelativeToBase((CFAllocatorRef)NULL,
+ buffer__in__, buffer__len__,
+ isDirectory,
+ baseURL);
+ _res = Py_BuildValue("O&",
+ CFURLRefObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CF_CFURLCreateFromFSRef(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ CFURLRef _rv;
+ FSRef fsRef;
+#ifndef CFURLCreateFromFSRef
+ PyMac_PRECHECK(CFURLCreateFromFSRef);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ PyMac_GetFSRef, &fsRef))
+ return NULL;
+ _rv = CFURLCreateFromFSRef((CFAllocatorRef)NULL,
+ &fsRef);
+ _res = Py_BuildValue("O&",
+ CFURLRefObj_New, _rv);
+ return _res;
+}
+
static PyMethodDef CF_methods[] = {
+ {"__CFRangeMake", (PyCFunction)CF___CFRangeMake, 1,
+ "(CFIndex loc, CFIndex len) -> (CFRange _rv)"},
{"CFAllocatorGetTypeID", (PyCFunction)CF_CFAllocatorGetTypeID, 1,
"() -> (CFTypeID _rv)"},
{"CFAllocatorGetPreferredSizeForSize", (PyCFunction)CF_CFAllocatorGetPreferredSizeForSize, 1,
"(CFIndex size, CFOptionFlags hint) -> (CFIndex _rv)"},
{"CFCopyTypeIDDescription", (PyCFunction)CF_CFCopyTypeIDDescription, 1,
- "(CFTypeID theType) -> (CFStringRef _rv)"},
+ "(CFTypeID type_id) -> (CFStringRef _rv)"},
{"CFArrayGetTypeID", (PyCFunction)CF_CFArrayGetTypeID, 1,
"() -> (CFTypeID _rv)"},
{"CFArrayCreateMutable", (PyCFunction)CF_CFArrayCreateMutable, 1,
"(CFIndex capacity) -> (CFMutableArrayRef _rv)"},
{"CFArrayCreateMutableCopy", (PyCFunction)CF_CFArrayCreateMutableCopy, 1,
- "(CFIndex capacity, CFArrayRef srcArray) -> (CFMutableArrayRef _rv)"},
+ "(CFIndex capacity, CFArrayRef theArray) -> (CFMutableArrayRef _rv)"},
{"CFDataGetTypeID", (PyCFunction)CF_CFDataGetTypeID, 1,
"() -> (CFTypeID _rv)"},
{"CFDataCreate", (PyCFunction)CF_CFDataCreate, 1,
{"CFDataCreateMutable", (PyCFunction)CF_CFDataCreateMutable, 1,
"(CFIndex capacity) -> (CFMutableDataRef _rv)"},
{"CFDataCreateMutableCopy", (PyCFunction)CF_CFDataCreateMutableCopy, 1,
- "(CFIndex capacity, CFDataRef data) -> (CFMutableDataRef _rv)"},
+ "(CFIndex capacity, CFDataRef theData) -> (CFMutableDataRef _rv)"},
{"CFDictionaryGetTypeID", (PyCFunction)CF_CFDictionaryGetTypeID, 1,
"() -> (CFTypeID _rv)"},
{"CFDictionaryCreateMutable", (PyCFunction)CF_CFDictionaryCreateMutable, 1,
"(CFIndex capacity) -> (CFMutableDictionaryRef _rv)"},
{"CFDictionaryCreateMutableCopy", (PyCFunction)CF_CFDictionaryCreateMutableCopy, 1,
- "(CFIndex capacity, CFDictionaryRef dict) -> (CFMutableDictionaryRef _rv)"},
+ "(CFIndex capacity, CFDictionaryRef theDict) -> (CFMutableDictionaryRef _rv)"},
{"CFStringGetTypeID", (PyCFunction)CF_CFStringGetTypeID, 1,
"() -> (CFTypeID _rv)"},
{"CFStringCreateWithPascalString", (PyCFunction)CF_CFStringCreateWithPascalString, 1,
- "(StringPtr pStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
+ "(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
{"CFStringCreateWithCString", (PyCFunction)CF_CFStringCreateWithCString, 1,
"(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
{"CFStringCreateWithPascalStringNoCopy", (PyCFunction)CF_CFStringCreateWithPascalStringNoCopy, 1,
- "(StringPtr pStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
+ "(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
{"CFStringCreateWithCStringNoCopy", (PyCFunction)CF_CFStringCreateWithCStringNoCopy, 1,
"(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)"},
{"CFStringCreateMutable", (PyCFunction)CF_CFStringCreateMutable, 1,
"(UInt32 codepage) -> (CFStringEncoding _rv)"},
{"CFStringConvertEncodingToIANACharSetName", (PyCFunction)CF_CFStringConvertEncodingToIANACharSetName, 1,
"(CFStringEncoding encoding) -> (CFStringRef _rv)"},
+ {"CFStringGetMostCompatibleMacStringEncoding", (PyCFunction)CF_CFStringGetMostCompatibleMacStringEncoding, 1,
+ "(CFStringEncoding encoding) -> (CFStringEncoding _rv)"},
{"__CFStringMakeConstantString", (PyCFunction)CF___CFStringMakeConstantString, 1,
"(char* cStr) -> (CFStringRef _rv)"},
{"CFURLGetTypeID", (PyCFunction)CF_CFURLGetTypeID, 1,
"() -> (CFTypeID _rv)"},
{"CFURLCreateWithBytes", (PyCFunction)CF_CFURLCreateWithBytes, 1,
"(Buffer URLBytes, CFStringEncoding encoding, CFURLRef baseURL) -> (CFURLRef _rv)"},
+ {"CFURLCreateFromFileSystemRepresentation", (PyCFunction)CF_CFURLCreateFromFileSystemRepresentation, 1,
+ "(Buffer buffer, Boolean isDirectory) -> (CFURLRef _rv)"},
+ {"CFURLCreateFromFileSystemRepresentationRelativeToBase", (PyCFunction)CF_CFURLCreateFromFileSystemRepresentationRelativeToBase, 1,
+ "(Buffer buffer, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)"},
+ {"CFURLCreateFromFSRef", (PyCFunction)CF_CFURLCreateFromFSRef, 1,
+ "(FSRef fsRef) -> (CFURLRef _rv)"},
{NULL, NULL, 0}
};
CFStringEncoding = Type("CFStringEncoding", "l")
CFComparisonResult = Type("CFComparisonResult", "l") # a bit dangerous, it's an enum
CFURLPathStyle = Type("CFURLPathStyle", "l") # a bit dangerous, it's an enum
+FSRef_ptr = OpaqueType("FSRef", "PyMac_BuildFSRef", "PyMac_GetFSRef")
+FSRef = OpaqueByValueType("FSRef", "PyMac_BuildFSRef", "PyMac_GetFSRef")
char_ptr = stringptr
return_stringptr = Type("char *", "s") # ONLY FOR RETURN VALUES!!
return _res;
}
+static PyObject *CmpObj_ResolveComponentAlias(ComponentObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Component _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = ResolveComponentAlias(_self->ob_itself);
+ _res = Py_BuildValue("O&",
+ CmpObj_New, _rv);
+ return _res;
+}
+
+static PyObject *CmpObj_GetComponentPublicIndString(ComponentObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSErr _err;
+ Str255 theString;
+ short strListID;
+ short index;
+ if (!PyArg_ParseTuple(_args, "O&hh",
+ PyMac_GetStr255, theString,
+ &strListID,
+ &index))
+ return NULL;
+ _err = GetComponentPublicIndString(_self->ob_itself,
+ theString,
+ strListID,
+ index);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *CmpObj_GetComponentRefcon(ComponentObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
-static PyObject *CmpObj_ResolveComponentAlias(ComponentObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- Component _rv;
- if (!PyArg_ParseTuple(_args, ""))
- return NULL;
- _rv = ResolveComponentAlias(_self->ob_itself);
- _res = Py_BuildValue("O&",
- CmpObj_New, _rv);
- return _res;
-}
-
static PyObject *CmpObj_CountComponentInstances(ComponentObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
"(Handle componentName, Handle componentInfo, Handle componentIcon) -> (ComponentDescription cd)"},
{"OpenComponent", (PyCFunction)CmpObj_OpenComponent, 1,
"() -> (ComponentInstance _rv)"},
+ {"ResolveComponentAlias", (PyCFunction)CmpObj_ResolveComponentAlias, 1,
+ "() -> (Component _rv)"},
+ {"GetComponentPublicIndString", (PyCFunction)CmpObj_GetComponentPublicIndString, 1,
+ "(Str255 theString, short strListID, short index) -> None"},
{"GetComponentRefcon", (PyCFunction)CmpObj_GetComponentRefcon, 1,
"() -> (long _rv)"},
{"SetComponentRefcon", (PyCFunction)CmpObj_SetComponentRefcon, 1,
"(OSType resType, short resID) -> (Handle theResource)"},
{"GetComponentIndString", (PyCFunction)CmpObj_GetComponentIndString, 1,
"(Str255 theString, short strListID, short index) -> None"},
- {"ResolveComponentAlias", (PyCFunction)CmpObj_ResolveComponentAlias, 1,
- "() -> (Component _rv)"},
{"CountComponentInstances", (PyCFunction)CmpObj_CountComponentInstances, 1,
"() -> (long _rv)"},
{"SetDefaultComponent", (PyCFunction)CmpObj_SetDefaultComponent, 1,
"() -> None"},
{"GetDialogPort", (PyCFunction)DlgObj_GetDialogPort, 1,
"() -> (CGrafPtr _rv)"},
-
{NULL, NULL, 0}
};
'SetDialogMovableModal',
'GetDialogControlNotificationProc',
'SetGrafPortOfDialog', # Funny, and probably not useful
+ # Can't find these:
+ 'CloseStandardSheet',
+ 'RunStandardAlert',
]
def makegreylist(self):
return [
- ('#if !TARGET_API_MAC_CARBON', [
- 'SetGrafPortOfDialog',
- ]),
('#if TARGET_API_MAC_CARBON', [
'InsertDialogItem',
'RemoveDialogItems',
'GetParamText',
+ 'CloseStandardSheet',
+ 'RunStandardAlert',
])]
def makeblacklisttypes(self):
"AlertStdAlertParamPtr", # Too much work, for now
"AlertStdAlertParamRec", # ditto
"AlertStdAlertParamRec_ptr", # ditto
+ "AlertStdCFStringAlertParamPtr", # ditto
+ "AlertStdCFStringAlertParamRec",
+ "AlertStdCFStringAlertParamRec_ptr",
"QTModelessCallbackProcPtr",
]
for f in functions: module.add(f)
for f in methods: object.add(f)
-# Some methods that are currently macro's in C, but will be real routines
-# in MacOS 8.
-
-##f = Method(ExistingWindowPtr, 'GetDialogWindow', (DialogRef, 'dialog', InMode))
-##object.add(f)
-##f = Method(SInt16, 'GetDialogDefaultItem', (DialogRef, 'dialog', InMode))
-##object.add(f)
-##f = Method(SInt16, 'GetDialogCancelItem', (DialogRef, 'dialog', InMode))
-##object.add(f)
-##f = Method(SInt16, 'GetDialogKeyboardFocusItem', (DialogRef, 'dialog', InMode))
-##object.add(f)
-f = Method(void, 'SetGrafPortOfDialog', (DialogRef, 'dialog', InMode),
- condition='#if !TARGET_API_MAC_CARBON')
-object.add(f)
-
setuseritembody = """
PyObject *new = NULL;
return _res;
}
-static PyObject *Evt_TickCount(PyObject *_self, PyObject *_args)
-{
- PyObject *_res = NULL;
- UInt32 _rv;
- if (!PyArg_ParseTuple(_args, ""))
- return NULL;
- _rv = TickCount();
- _res = Py_BuildValue("l",
- _rv);
- return _res;
-}
-
static PyObject *Evt_GetCaretTime(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
}
#endif
+static PyObject *Evt_KeyScript(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ short code;
+ if (!PyArg_ParseTuple(_args, "h",
+ &code))
+ return NULL;
+ KeyScript(code);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Evt_IsCmdChar(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ EventRecord event;
+ short test;
+ if (!PyArg_ParseTuple(_args, "O&h",
+ PyMac_GetEventRecord, &event,
+ &test))
+ return NULL;
+ _rv = IsCmdChar(&event,
+ test);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Evt_LMGetKeyThresh(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetKeyThresh();
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Evt_LMSetKeyThresh(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 value;
+ if (!PyArg_ParseTuple(_args, "h",
+ &value))
+ return NULL;
+ LMSetKeyThresh(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Evt_LMGetKeyRepThresh(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetKeyRepThresh();
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
+static PyObject *Evt_LMSetKeyRepThresh(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 value;
+ if (!PyArg_ParseTuple(_args, "h",
+ &value))
+ return NULL;
+ LMSetKeyRepThresh(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Evt_LMGetKbdLast(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt8 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetKbdLast();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Evt_LMSetKbdLast(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt8 value;
+ if (!PyArg_ParseTuple(_args, "b",
+ &value))
+ return NULL;
+ LMSetKbdLast(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
+static PyObject *Evt_LMGetKbdType(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt8 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetKbdType();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *Evt_LMSetKbdType(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt8 value;
+ if (!PyArg_ParseTuple(_args, "b",
+ &value))
+ return NULL;
+ LMSetKbdType(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *Evt_WaitNextEvent(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
"() -> (Boolean _rv)"},
{"WaitMouseUp", (PyCFunction)Evt_WaitMouseUp, 1,
"() -> (Boolean _rv)"},
- {"TickCount", (PyCFunction)Evt_TickCount, 1,
- "() -> (UInt32 _rv)"},
{"GetCaretTime", (PyCFunction)Evt_GetCaretTime, 1,
"() -> (UInt32 _rv)"},
{"GetKeys", (PyCFunction)Evt_GetKeys, 1,
{"CheckEventQueueForUserCancel", (PyCFunction)Evt_CheckEventQueueForUserCancel, 1,
"() -> (Boolean _rv)"},
#endif
+ {"KeyScript", (PyCFunction)Evt_KeyScript, 1,
+ "(short code) -> None"},
+ {"IsCmdChar", (PyCFunction)Evt_IsCmdChar, 1,
+ "(EventRecord event, short test) -> (Boolean _rv)"},
+ {"LMGetKeyThresh", (PyCFunction)Evt_LMGetKeyThresh, 1,
+ "() -> (SInt16 _rv)"},
+ {"LMSetKeyThresh", (PyCFunction)Evt_LMSetKeyThresh, 1,
+ "(SInt16 value) -> None"},
+ {"LMGetKeyRepThresh", (PyCFunction)Evt_LMGetKeyRepThresh, 1,
+ "() -> (SInt16 _rv)"},
+ {"LMSetKeyRepThresh", (PyCFunction)Evt_LMSetKeyRepThresh, 1,
+ "(SInt16 value) -> None"},
+ {"LMGetKbdLast", (PyCFunction)Evt_LMGetKbdLast, 1,
+ "() -> (UInt8 _rv)"},
+ {"LMSetKbdLast", (PyCFunction)Evt_LMSetKbdLast, 1,
+ "(UInt8 value) -> None"},
+ {"LMGetKbdType", (PyCFunction)Evt_LMGetKbdType, 1,
+ "() -> (UInt8 _rv)"},
+ {"LMSetKbdType", (PyCFunction)Evt_LMSetKbdType, 1,
+ "(UInt8 value) -> None"},
{"WaitNextEvent", (PyCFunction)Evt_WaitNextEvent, 1,
"(EventMask eventMask, UInt32 sleep [,RegionHandle]) -> (Boolean _rv, EventRecord theEvent)"},
{NULL, NULL, 0}
{
PyObject *_res = NULL;
OSErr _err;
- MenuHandle mh;
+ MenuRef mh;
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = HMGetHelpMenuHandle(&mh);
_err = HMGetBalloonWindow(&window);
if (_err != noErr) return PyMac_Error(_err);
_res = Py_BuildValue("O&",
- WinObj_WhichWindow, window);
+ WinObj_New, window);
return _res;
}
static PyMethodDef Help_methods[] = {
{"HMGetHelpMenuHandle", (PyCFunction)Help_HMGetHelpMenuHandle, 1,
- "() -> (MenuHandle mh)"},
+ "() -> (MenuRef mh)"},
{"HMRemoveBalloon", (PyCFunction)Help_HMRemoveBalloon, 1,
"() -> None"},
{"HMIsBalloon", (PyCFunction)Help_HMIsBalloon, 1,
PyObject *_res = NULL;
Boolean _rv;
Point pt;
- short modifiers;
- if (!PyArg_ParseTuple(_args, "O&h",
+ EventModifiers modifiers;
+ if (!PyArg_ParseTuple(_args, "O&H",
PyMac_GetPoint, &pt,
&modifiers))
return NULL;
{"LCellSize", (PyCFunction)ListObj_LCellSize, 1,
"(Point cSize) -> None"},
{"LClick", (PyCFunction)ListObj_LClick, 1,
- "(Point pt, short modifiers) -> (Boolean _rv)"},
+ "(Point pt, EventModifiers modifiers) -> (Boolean _rv)"},
{"LAddToCell", (PyCFunction)ListObj_LAddToCell, 1,
"(Buffer dataPtr, Point theCell) -> None"},
{"LClrCell", (PyCFunction)ListObj_LClrCell, 1,
def makeblacklisttypes(self):
return [
"ListClickLoopUPP", # Too difficult for now
+ "ListDefSpecPtr", # later
]
def makerepairinstructions(self):
DataHandle = OpaqueByValueType("DataHandle", "ResObj")
Handle = OpaqueByValueType("Handle", "ResObj")
CGrafPtr = OpaqueByValueType("CGrafPtr", "GrafObj")
+EventModifiers = Type("EventModifiers", "H")
includestuff = includestuff + """
#ifdef WITHOUT_FRAMEWORKS
return _res;
}
-static PyObject *MenuObj_CountMenuItems(MenuObject *_self, PyObject *_args)
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_CountMItems(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
short _rv;
-#ifndef CountMenuItems
- PyMac_PRECHECK(CountMenuItems);
+#ifndef CountMItems
+ PyMac_PRECHECK(CountMItems);
#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = CountMenuItems(_self->ob_itself);
+ _rv = CountMItems(_self->ob_itself);
_res = Py_BuildValue("h",
_rv);
return _res;
}
+#endif
-#if !TARGET_API_MAC_CARBON
-
-static PyObject *MenuObj_CountMItems(MenuObject *_self, PyObject *_args)
+static PyObject *MenuObj_CountMenuItems(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
short _rv;
-#ifndef CountMItems
- PyMac_PRECHECK(CountMItems);
+#ifndef CountMenuItems
+ PyMac_PRECHECK(CountMenuItems);
#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _rv = CountMItems(_self->ob_itself);
+ _rv = CountMenuItems(_self->ob_itself);
_res = Py_BuildValue("h",
_rv);
return _res;
}
-#endif
static PyObject *MenuObj_GetMenuFont(MenuObject *_self, PyObject *_args)
{
return _res;
}
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_IsValidMenu(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+#ifndef IsValidMenu
+ PyMac_PRECHECK(IsValidMenu);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = IsValidMenu(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_GetMenuRetainCount(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ ItemCount _rv;
+#ifndef GetMenuRetainCount
+ PyMac_PRECHECK(GetMenuRetainCount);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = GetMenuRetainCount(_self->ob_itself);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_RetainMenu(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+#ifndef RetainMenu
+ PyMac_PRECHECK(RetainMenu);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = RetainMenu(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_ReleaseMenu(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+#ifndef ReleaseMenu
+ PyMac_PRECHECK(ReleaseMenu);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = ReleaseMenu(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_DuplicateMenu(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuHandle outMenu;
+#ifndef DuplicateMenu
+ PyMac_PRECHECK(DuplicateMenu);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = DuplicateMenu(_self->ob_itself,
+ &outMenu);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ MenuObj_New, outMenu);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_CopyMenuTitleAsCFString(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ CFStringRef outString;
+#ifndef CopyMenuTitleAsCFString
+ PyMac_PRECHECK(CopyMenuTitleAsCFString);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = CopyMenuTitleAsCFString(_self->ob_itself,
+ &outString);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, outString);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_SetMenuTitleWithCFString(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ CFStringRef inString;
+#ifndef SetMenuTitleWithCFString
+ PyMac_PRECHECK(SetMenuTitleWithCFString);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&",
+ CFStringRefObj_Convert, &inString))
+ return NULL;
+ _err = SetMenuTitleWithCFString(_self->ob_itself,
+ inString);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_InvalidateMenuSize(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+#ifndef InvalidateMenuSize
+ PyMac_PRECHECK(InvalidateMenuSize);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = InvalidateMenuSize(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_IsMenuSizeInvalid(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+#ifndef IsMenuSizeInvalid
+ PyMac_PRECHECK(IsMenuSizeInvalid);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = IsMenuSizeInvalid(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
static PyObject *MenuObj_MacAppendMenu(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_CopyMenuItems(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuItemIndex inFirstItem;
+ ItemCount inNumItems;
+ MenuHandle inDestMenu;
+ MenuItemIndex inInsertAfter;
+#ifndef CopyMenuItems
+ PyMac_PRECHECK(CopyMenuItems);
+#endif
+ if (!PyArg_ParseTuple(_args, "hlO&h",
+ &inFirstItem,
+ &inNumItems,
+ MenuObj_Convert, &inDestMenu,
+ &inInsertAfter))
+ return NULL;
+ _err = CopyMenuItems(_self->ob_itself,
+ inFirstItem,
+ inNumItems,
+ inDestMenu,
+ inInsertAfter);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_DeleteMenuItems(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuItemIndex inFirstItem;
+ ItemCount inNumItems;
+#ifndef DeleteMenuItems
+ PyMac_PRECHECK(DeleteMenuItems);
+#endif
+ if (!PyArg_ParseTuple(_args, "hl",
+ &inFirstItem,
+ &inNumItems))
+ return NULL;
+ _err = DeleteMenuItems(_self->ob_itself,
+ inFirstItem,
+ inNumItems);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_AppendMenuItemTextWithCFString(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ CFStringRef inString;
+ MenuItemAttributes inAttributes;
+ MenuCommand inCommandID;
+ MenuItemIndex outNewItem;
+#ifndef AppendMenuItemTextWithCFString
+ PyMac_PRECHECK(AppendMenuItemTextWithCFString);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&ll",
+ CFStringRefObj_Convert, &inString,
+ &inAttributes,
+ &inCommandID))
+ return NULL;
+ _err = AppendMenuItemTextWithCFString(_self->ob_itself,
+ inString,
+ inAttributes,
+ inCommandID,
+ &outNewItem);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("h",
+ outNewItem);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_InsertMenuItemTextWithCFString(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ CFStringRef inString;
+ MenuItemIndex inAfterItem;
+ MenuItemAttributes inAttributes;
+ MenuCommand inCommandID;
+#ifndef InsertMenuItemTextWithCFString
+ PyMac_PRECHECK(InsertMenuItemTextWithCFString);
+#endif
+ if (!PyArg_ParseTuple(_args, "O&hll",
+ CFStringRefObj_Convert, &inString,
+ &inAfterItem,
+ &inAttributes,
+ &inCommandID))
+ return NULL;
+ _err = InsertMenuItemTextWithCFString(_self->ob_itself,
+ inString,
+ inAfterItem,
+ inAttributes,
+ inCommandID);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
static PyObject *MenuObj_PopUpMenuSelect(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_InvalidateMenuEnabling(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+#ifndef InvalidateMenuEnabling
+ PyMac_PRECHECK(InvalidateMenuEnabling);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = InvalidateMenuEnabling(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_IsMenuBarInvalid(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+#ifndef IsMenuBarInvalid
+ PyMac_PRECHECK(IsMenuBarInvalid);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = IsMenuBarInvalid(_self->ob_itself);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
static PyObject *MenuObj_MacInsertMenu(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
-static PyObject *MenuObj_MacCheckMenuItem(MenuObject *_self, PyObject *_args)
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_SetRootMenu(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+#ifndef SetRootMenu
+ PyMac_PRECHECK(SetRootMenu);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = SetRootMenu(_self->ob_itself);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_CheckItem(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
short item;
Boolean checked;
-#ifndef MacCheckMenuItem
- PyMac_PRECHECK(MacCheckMenuItem);
+#ifndef CheckItem
+ PyMac_PRECHECK(CheckItem);
#endif
if (!PyArg_ParseTuple(_args, "hb",
&item,
&checked))
return NULL;
- MacCheckMenuItem(_self->ob_itself,
- item,
- checked);
+ CheckItem(_self->ob_itself,
+ item,
+ checked);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
+#endif
-#if !TARGET_API_MAC_CARBON
-
-static PyObject *MenuObj_CheckItem(MenuObject *_self, PyObject *_args)
+static PyObject *MenuObj_MacCheckMenuItem(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
short item;
Boolean checked;
-#ifndef CheckItem
- PyMac_PRECHECK(CheckItem);
+#ifndef MacCheckMenuItem
+ PyMac_PRECHECK(MacCheckMenuItem);
#endif
if (!PyArg_ParseTuple(_args, "hb",
&item,
&checked))
return NULL;
- CheckItem(_self->ob_itself,
- item,
- checked);
+ MacCheckMenuItem(_self->ob_itself,
+ item,
+ checked);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-#endif
static PyObject *MenuObj_SetMenuItemText(MenuObject *_self, PyObject *_args)
{
#if TARGET_API_MAC_CARBON
+static PyObject *MenuObj_SetMenuItemHierarchicalMenu(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuItemIndex inItem;
+ MenuHandle inHierMenu;
+#ifndef SetMenuItemHierarchicalMenu
+ PyMac_PRECHECK(SetMenuItemHierarchicalMenu);
+#endif
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &inItem,
+ MenuObj_Convert, &inHierMenu))
+ return NULL;
+ _err = SetMenuItemHierarchicalMenu(_self->ob_itself,
+ inItem,
+ inHierMenu);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_GetMenuItemHierarchicalMenu(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuItemIndex inItem;
+ MenuHandle outHierMenu;
+#ifndef GetMenuItemHierarchicalMenu
+ PyMac_PRECHECK(GetMenuItemHierarchicalMenu);
+#endif
+ if (!PyArg_ParseTuple(_args, "h",
+ &inItem))
+ return NULL;
+ _err = GetMenuItemHierarchicalMenu(_self->ob_itself,
+ inItem,
+ &outHierMenu);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ MenuObj_New, outHierMenu);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_CopyMenuItemTextAsCFString(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuItemIndex inItem;
+ CFStringRef outString;
+#ifndef CopyMenuItemTextAsCFString
+ PyMac_PRECHECK(CopyMenuItemTextAsCFString);
+#endif
+ if (!PyArg_ParseTuple(_args, "h",
+ &inItem))
+ return NULL;
+ _err = CopyMenuItemTextAsCFString(_self->ob_itself,
+ inItem,
+ &outString);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&",
+ CFStringRefObj_New, outString);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_SetMenuItemTextWithCFString(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuItemIndex inItem;
+ CFStringRef inString;
+#ifndef SetMenuItemTextWithCFString
+ PyMac_PRECHECK(SetMenuItemTextWithCFString);
+#endif
+ if (!PyArg_ParseTuple(_args, "hO&",
+ &inItem,
+ CFStringRefObj_Convert, &inString))
+ return NULL;
+ _err = SetMenuItemTextWithCFString(_self->ob_itself,
+ inItem,
+ inString);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_GetMenuItemIndent(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuItemIndex inItem;
+ UInt32 outIndent;
+#ifndef GetMenuItemIndent
+ PyMac_PRECHECK(GetMenuItemIndent);
+#endif
+ if (!PyArg_ParseTuple(_args, "h",
+ &inItem))
+ return NULL;
+ _err = GetMenuItemIndent(_self->ob_itself,
+ inItem,
+ &outIndent);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outIndent);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_SetMenuItemIndent(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuItemIndex inItem;
+ UInt32 inIndent;
+#ifndef SetMenuItemIndent
+ PyMac_PRECHECK(SetMenuItemIndent);
+#endif
+ if (!PyArg_ParseTuple(_args, "hl",
+ &inItem,
+ &inIndent))
+ return NULL;
+ _err = SetMenuItemIndent(_self->ob_itself,
+ inItem,
+ inIndent);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_GetMenuItemCommandKey(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuItemIndex inItem;
+ Boolean inGetVirtualKey;
+ UInt16 outKey;
+#ifndef GetMenuItemCommandKey
+ PyMac_PRECHECK(GetMenuItemCommandKey);
+#endif
+ if (!PyArg_ParseTuple(_args, "hb",
+ &inItem,
+ &inGetVirtualKey))
+ return NULL;
+ _err = GetMenuItemCommandKey(_self->ob_itself,
+ inItem,
+ inGetVirtualKey,
+ &outKey);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("H",
+ outKey);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_SetMenuItemCommandKey(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuItemIndex inItem;
+ Boolean inSetVirtualKey;
+ UInt16 inKey;
+#ifndef SetMenuItemCommandKey
+ PyMac_PRECHECK(SetMenuItemCommandKey);
+#endif
+ if (!PyArg_ParseTuple(_args, "hbH",
+ &inItem,
+ &inSetVirtualKey,
+ &inKey))
+ return NULL;
+ _err = SetMenuItemCommandKey(_self->ob_itself,
+ inItem,
+ inSetVirtualKey,
+ inKey);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
static PyObject *MenuObj_GetMenuItemPropertyAttributes(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
#if TARGET_API_MAC_CARBON
+static PyObject *MenuObj_GetMenuType(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ UInt16 outType;
+#ifndef GetMenuType
+ PyMac_PRECHECK(GetMenuType);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _err = GetMenuType(_self->ob_itself,
+ &outType);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("H",
+ outType);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
static PyObject *MenuObj_CountMenuItemsWithCommandID(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
ItemCount _rv;
- MenuCommand commandID;
+ MenuCommand inCommandID;
#ifndef CountMenuItemsWithCommandID
PyMac_PRECHECK(CountMenuItemsWithCommandID);
#endif
- if (!PyArg_ParseTuple(_args, "l",
- &commandID))
+ if (!PyArg_ParseTuple(_args, "l",
+ &inCommandID))
+ return NULL;
+ _rv = CountMenuItemsWithCommandID(_self->ob_itself,
+ inCommandID);
+ _res = Py_BuildValue("l",
+ _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_GetIndMenuItemWithCommandID(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuCommand inCommandID;
+ UInt32 inItemIndex;
+ MenuHandle outMenu;
+ MenuItemIndex outIndex;
+#ifndef GetIndMenuItemWithCommandID
+ PyMac_PRECHECK(GetIndMenuItemWithCommandID);
+#endif
+ if (!PyArg_ParseTuple(_args, "ll",
+ &inCommandID,
+ &inItemIndex))
+ return NULL;
+ _err = GetIndMenuItemWithCommandID(_self->ob_itself,
+ inCommandID,
+ inItemIndex,
+ &outMenu,
+ &outIndex);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("O&h",
+ MenuObj_New, outMenu,
+ outIndex);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_EnableMenuCommand(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuCommand inCommandID;
+#ifndef EnableMenuCommand
+ PyMac_PRECHECK(EnableMenuCommand);
+#endif
+ if (!PyArg_ParseTuple(_args, "l",
+ &inCommandID))
+ return NULL;
+ EnableMenuCommand(_self->ob_itself,
+ inCommandID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_DisableMenuCommand(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuCommand inCommandID;
+#ifndef DisableMenuCommand
+ PyMac_PRECHECK(DisableMenuCommand);
+#endif
+ if (!PyArg_ParseTuple(_args, "l",
+ &inCommandID))
+ return NULL;
+ DisableMenuCommand(_self->ob_itself,
+ inCommandID);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_IsMenuCommandEnabled(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ Boolean _rv;
+ MenuCommand inCommandID;
+#ifndef IsMenuCommandEnabled
+ PyMac_PRECHECK(IsMenuCommandEnabled);
+#endif
+ if (!PyArg_ParseTuple(_args, "l",
+ &inCommandID))
+ return NULL;
+ _rv = IsMenuCommandEnabled(_self->ob_itself,
+ inCommandID);
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+#endif
+
+#if TARGET_API_MAC_CARBON
+
+static PyObject *MenuObj_SetMenuCommandMark(MenuObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ OSStatus _err;
+ MenuCommand inCommandID;
+ UniChar inMark;
+#ifndef SetMenuCommandMark
+ PyMac_PRECHECK(SetMenuCommandMark);
+#endif
+ if (!PyArg_ParseTuple(_args, "lh",
+ &inCommandID,
+ &inMark))
return NULL;
- _rv = CountMenuItemsWithCommandID(_self->ob_itself,
- commandID);
- _res = Py_BuildValue("l",
- _rv);
+ _err = SetMenuCommandMark(_self->ob_itself,
+ inCommandID,
+ inMark);
+ if (_err != noErr) return PyMac_Error(_err);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
#endif
#if TARGET_API_MAC_CARBON
-static PyObject *MenuObj_GetIndMenuItemWithCommandID(MenuObject *_self, PyObject *_args)
+static PyObject *MenuObj_GetMenuCommandMark(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
OSStatus _err;
- MenuCommand commandID;
- UInt32 itemIndex;
- MenuHandle outMenu;
- MenuItemIndex outIndex;
-#ifndef GetIndMenuItemWithCommandID
- PyMac_PRECHECK(GetIndMenuItemWithCommandID);
+ MenuCommand inCommandID;
+ UniChar outMark;
+#ifndef GetMenuCommandMark
+ PyMac_PRECHECK(GetMenuCommandMark);
#endif
- if (!PyArg_ParseTuple(_args, "ll",
- &commandID,
- &itemIndex))
+ if (!PyArg_ParseTuple(_args, "l",
+ &inCommandID))
return NULL;
- _err = GetIndMenuItemWithCommandID(_self->ob_itself,
- commandID,
- itemIndex,
- &outMenu,
- &outIndex);
+ _err = GetMenuCommandMark(_self->ob_itself,
+ inCommandID,
+ &outMark);
if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("O&h",
- MenuObj_New, outMenu,
- outIndex);
+ _res = Py_BuildValue("h",
+ outMark);
return _res;
}
#endif
#if TARGET_API_MAC_CARBON
-static PyObject *MenuObj_EnableMenuCommand(MenuObject *_self, PyObject *_args)
+static PyObject *MenuObj_GetMenuCommandPropertySize(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
- MenuCommand commandID;
-#ifndef EnableMenuCommand
- PyMac_PRECHECK(EnableMenuCommand);
+ OSStatus _err;
+ MenuCommand inCommandID;
+ OSType inPropertyCreator;
+ OSType inPropertyTag;
+ ByteCount outSize;
+#ifndef GetMenuCommandPropertySize
+ PyMac_PRECHECK(GetMenuCommandPropertySize);
#endif
- if (!PyArg_ParseTuple(_args, "l",
- &commandID))
+ if (!PyArg_ParseTuple(_args, "lO&O&",
+ &inCommandID,
+ PyMac_GetOSType, &inPropertyCreator,
+ PyMac_GetOSType, &inPropertyTag))
return NULL;
- EnableMenuCommand(_self->ob_itself,
- commandID);
- Py_INCREF(Py_None);
- _res = Py_None;
+ _err = GetMenuCommandPropertySize(_self->ob_itself,
+ inCommandID,
+ inPropertyCreator,
+ inPropertyTag,
+ &outSize);
+ if (_err != noErr) return PyMac_Error(_err);
+ _res = Py_BuildValue("l",
+ outSize);
return _res;
}
#endif
#if TARGET_API_MAC_CARBON
-static PyObject *MenuObj_DisableMenuCommand(MenuObject *_self, PyObject *_args)
+static PyObject *MenuObj_RemoveMenuCommandProperty(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
- MenuCommand commandID;
-#ifndef DisableMenuCommand
- PyMac_PRECHECK(DisableMenuCommand);
+ OSStatus _err;
+ MenuCommand inCommandID;
+ OSType inPropertyCreator;
+ OSType inPropertyTag;
+#ifndef RemoveMenuCommandProperty
+ PyMac_PRECHECK(RemoveMenuCommandProperty);
#endif
- if (!PyArg_ParseTuple(_args, "l",
- &commandID))
+ if (!PyArg_ParseTuple(_args, "lO&O&",
+ &inCommandID,
+ PyMac_GetOSType, &inPropertyCreator,
+ PyMac_GetOSType, &inPropertyTag))
return NULL;
- DisableMenuCommand(_self->ob_itself,
- commandID);
+ _err = RemoveMenuCommandProperty(_self->ob_itself,
+ inCommandID,
+ inPropertyCreator,
+ inPropertyTag);
+ if (_err != noErr) return PyMac_Error(_err);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
#if TARGET_API_MAC_CARBON
-static PyObject *MenuObj_IsMenuCommandEnabled(MenuObject *_self, PyObject *_args)
+static PyObject *MenuObj_IsMenuItemInvalid(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
Boolean _rv;
- MenuCommand commandID;
-#ifndef IsMenuCommandEnabled
- PyMac_PRECHECK(IsMenuCommandEnabled);
+ MenuItemIndex item;
+#ifndef IsMenuItemInvalid
+ PyMac_PRECHECK(IsMenuItemInvalid);
#endif
- if (!PyArg_ParseTuple(_args, "l",
- &commandID))
+ if (!PyArg_ParseTuple(_args, "h",
+ &item))
return NULL;
- _rv = IsMenuCommandEnabled(_self->ob_itself,
- commandID);
+ _rv = IsMenuItemInvalid(_self->ob_itself,
+ item);
_res = Py_BuildValue("b",
_rv);
return _res;
#if TARGET_API_MAC_CARBON
-static PyObject *MenuObj_GetMenuCommandPropertySize(MenuObject *_self, PyObject *_args)
+static PyObject *MenuObj_InvalidateMenuItems(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
OSStatus _err;
- MenuCommand commandID;
- OSType propertyCreator;
- OSType propertyTag;
- ByteCount size;
-#ifndef GetMenuCommandPropertySize
- PyMac_PRECHECK(GetMenuCommandPropertySize);
+ MenuItemIndex firstItem;
+ ItemCount numItems;
+#ifndef InvalidateMenuItems
+ PyMac_PRECHECK(InvalidateMenuItems);
#endif
- if (!PyArg_ParseTuple(_args, "lO&O&",
- &commandID,
- PyMac_GetOSType, &propertyCreator,
- PyMac_GetOSType, &propertyTag))
+ if (!PyArg_ParseTuple(_args, "hl",
+ &firstItem,
+ &numItems))
return NULL;
- _err = GetMenuCommandPropertySize(_self->ob_itself,
- commandID,
- propertyCreator,
- propertyTag,
- &size);
+ _err = InvalidateMenuItems(_self->ob_itself,
+ firstItem,
+ numItems);
if (_err != noErr) return PyMac_Error(_err);
- _res = Py_BuildValue("l",
- size);
+ Py_INCREF(Py_None);
+ _res = Py_None;
return _res;
}
#endif
#if TARGET_API_MAC_CARBON
-static PyObject *MenuObj_RemoveMenuCommandProperty(MenuObject *_self, PyObject *_args)
+static PyObject *MenuObj_UpdateInvalidMenuItems(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
OSStatus _err;
- MenuCommand commandID;
- OSType propertyCreator;
- OSType propertyTag;
-#ifndef RemoveMenuCommandProperty
- PyMac_PRECHECK(RemoveMenuCommandProperty);
+#ifndef UpdateInvalidMenuItems
+ PyMac_PRECHECK(UpdateInvalidMenuItems);
#endif
- if (!PyArg_ParseTuple(_args, "lO&O&",
- &commandID,
- PyMac_GetOSType, &propertyCreator,
- PyMac_GetOSType, &propertyTag))
+ if (!PyArg_ParseTuple(_args, ""))
return NULL;
- _err = RemoveMenuCommandProperty(_self->ob_itself,
- commandID,
- propertyCreator,
- propertyTag);
+ _err = UpdateInvalidMenuItems(_self->ob_itself);
if (_err != noErr) return PyMac_Error(_err);
Py_INCREF(Py_None);
_res = Py_None;
"() -> None"},
{"CalcMenuSize", (PyCFunction)MenuObj_CalcMenuSize, 1,
"() -> None"},
- {"CountMenuItems", (PyCFunction)MenuObj_CountMenuItems, 1,
- "() -> (short _rv)"},
#if !TARGET_API_MAC_CARBON
{"CountMItems", (PyCFunction)MenuObj_CountMItems, 1,
"() -> (short _rv)"},
#endif
+ {"CountMenuItems", (PyCFunction)MenuObj_CountMenuItems, 1,
+ "() -> (short _rv)"},
{"GetMenuFont", (PyCFunction)MenuObj_GetMenuFont, 1,
"() -> (SInt16 outFontID, UInt16 outFontSize)"},
{"SetMenuFont", (PyCFunction)MenuObj_SetMenuFont, 1,
"() -> (Boolean _rv)"},
{"SetMenuExcludesMarkColumn", (PyCFunction)MenuObj_SetMenuExcludesMarkColumn, 1,
"(Boolean excludesMark) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"IsValidMenu", (PyCFunction)MenuObj_IsValidMenu, 1,
+ "() -> (Boolean _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetMenuRetainCount", (PyCFunction)MenuObj_GetMenuRetainCount, 1,
+ "() -> (ItemCount _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"RetainMenu", (PyCFunction)MenuObj_RetainMenu, 1,
+ "() -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"ReleaseMenu", (PyCFunction)MenuObj_ReleaseMenu, 1,
+ "() -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"DuplicateMenu", (PyCFunction)MenuObj_DuplicateMenu, 1,
+ "() -> (MenuHandle outMenu)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"CopyMenuTitleAsCFString", (PyCFunction)MenuObj_CopyMenuTitleAsCFString, 1,
+ "() -> (CFStringRef outString)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"SetMenuTitleWithCFString", (PyCFunction)MenuObj_SetMenuTitleWithCFString, 1,
+ "(CFStringRef inString) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"InvalidateMenuSize", (PyCFunction)MenuObj_InvalidateMenuSize, 1,
+ "() -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"IsMenuSizeInvalid", (PyCFunction)MenuObj_IsMenuSizeInvalid, 1,
+ "() -> (Boolean _rv)"},
+#endif
{"MacAppendMenu", (PyCFunction)MenuObj_MacAppendMenu, 1,
"(Str255 data) -> None"},
{"InsertResMenu", (PyCFunction)MenuObj_InsertResMenu, 1,
"(Str255 inString) -> None"},
{"InsertMenuItemText", (PyCFunction)MenuObj_InsertMenuItemText, 1,
"(Str255 inString, MenuItemIndex afterItem) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"CopyMenuItems", (PyCFunction)MenuObj_CopyMenuItems, 1,
+ "(MenuItemIndex inFirstItem, ItemCount inNumItems, MenuHandle inDestMenu, MenuItemIndex inInsertAfter) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"DeleteMenuItems", (PyCFunction)MenuObj_DeleteMenuItems, 1,
+ "(MenuItemIndex inFirstItem, ItemCount inNumItems) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"AppendMenuItemTextWithCFString", (PyCFunction)MenuObj_AppendMenuItemTextWithCFString, 1,
+ "(CFStringRef inString, MenuItemAttributes inAttributes, MenuCommand inCommandID) -> (MenuItemIndex outNewItem)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"InsertMenuItemTextWithCFString", (PyCFunction)MenuObj_InsertMenuItemTextWithCFString, 1,
+ "(CFStringRef inString, MenuItemIndex inAfterItem, MenuItemAttributes inAttributes, MenuCommand inCommandID) -> None"},
+#endif
{"PopUpMenuSelect", (PyCFunction)MenuObj_PopUpMenuSelect, 1,
"(short top, short left, short popUpItem) -> (long _rv)"},
+
+#if TARGET_API_MAC_CARBON
+ {"InvalidateMenuEnabling", (PyCFunction)MenuObj_InvalidateMenuEnabling, 1,
+ "() -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"IsMenuBarInvalid", (PyCFunction)MenuObj_IsMenuBarInvalid, 1,
+ "() -> (Boolean _rv)"},
+#endif
{"MacInsertMenu", (PyCFunction)MenuObj_MacInsertMenu, 1,
"(MenuID beforeID) -> None"},
- {"MacCheckMenuItem", (PyCFunction)MenuObj_MacCheckMenuItem, 1,
- "(short item, Boolean checked) -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"SetRootMenu", (PyCFunction)MenuObj_SetRootMenu, 1,
+ "() -> None"},
+#endif
#if !TARGET_API_MAC_CARBON
{"CheckItem", (PyCFunction)MenuObj_CheckItem, 1,
"(short item, Boolean checked) -> None"},
#endif
+ {"MacCheckMenuItem", (PyCFunction)MenuObj_MacCheckMenuItem, 1,
+ "(short item, Boolean checked) -> None"},
{"SetMenuItemText", (PyCFunction)MenuObj_SetMenuItemText, 1,
"(short item, Str255 itemString) -> None"},
{"GetMenuItemText", (PyCFunction)MenuObj_GetMenuItemText, 1,
{"IsMenuItemIconEnabled", (PyCFunction)MenuObj_IsMenuItemIconEnabled, 1,
"(MenuItemIndex item) -> (Boolean _rv)"},
+#if TARGET_API_MAC_CARBON
+ {"SetMenuItemHierarchicalMenu", (PyCFunction)MenuObj_SetMenuItemHierarchicalMenu, 1,
+ "(MenuItemIndex inItem, MenuHandle inHierMenu) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetMenuItemHierarchicalMenu", (PyCFunction)MenuObj_GetMenuItemHierarchicalMenu, 1,
+ "(MenuItemIndex inItem) -> (MenuHandle outHierMenu)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"CopyMenuItemTextAsCFString", (PyCFunction)MenuObj_CopyMenuItemTextAsCFString, 1,
+ "(MenuItemIndex inItem) -> (CFStringRef outString)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"SetMenuItemTextWithCFString", (PyCFunction)MenuObj_SetMenuItemTextWithCFString, 1,
+ "(MenuItemIndex inItem, CFStringRef inString) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetMenuItemIndent", (PyCFunction)MenuObj_GetMenuItemIndent, 1,
+ "(MenuItemIndex inItem) -> (UInt32 outIndent)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"SetMenuItemIndent", (PyCFunction)MenuObj_SetMenuItemIndent, 1,
+ "(MenuItemIndex inItem, UInt32 inIndent) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetMenuItemCommandKey", (PyCFunction)MenuObj_GetMenuItemCommandKey, 1,
+ "(MenuItemIndex inItem, Boolean inGetVirtualKey) -> (UInt16 outKey)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"SetMenuItemCommandKey", (PyCFunction)MenuObj_SetMenuItemCommandKey, 1,
+ "(MenuItemIndex inItem, Boolean inSetVirtualKey, UInt16 inKey) -> None"},
+#endif
+
#if TARGET_API_MAC_CARBON
{"GetMenuItemPropertyAttributes", (PyCFunction)MenuObj_GetMenuItemPropertyAttributes, 1,
"(MenuItemIndex item, OSType propertyCreator, OSType propertyTag) -> (UInt32 attributes)"},
"() -> (Boolean _rv)"},
#endif
+#if TARGET_API_MAC_CARBON
+ {"GetMenuType", (PyCFunction)MenuObj_GetMenuType, 1,
+ "() -> (UInt16 outType)"},
+#endif
+
#if TARGET_API_MAC_CARBON
{"CountMenuItemsWithCommandID", (PyCFunction)MenuObj_CountMenuItemsWithCommandID, 1,
- "(MenuCommand commandID) -> (ItemCount _rv)"},
+ "(MenuCommand inCommandID) -> (ItemCount _rv)"},
#endif
#if TARGET_API_MAC_CARBON
{"GetIndMenuItemWithCommandID", (PyCFunction)MenuObj_GetIndMenuItemWithCommandID, 1,
- "(MenuCommand commandID, UInt32 itemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)"},
+ "(MenuCommand inCommandID, UInt32 inItemIndex) -> (MenuHandle outMenu, MenuItemIndex outIndex)"},
#endif
#if TARGET_API_MAC_CARBON
{"EnableMenuCommand", (PyCFunction)MenuObj_EnableMenuCommand, 1,
- "(MenuCommand commandID) -> None"},
+ "(MenuCommand inCommandID) -> None"},
#endif
#if TARGET_API_MAC_CARBON
{"DisableMenuCommand", (PyCFunction)MenuObj_DisableMenuCommand, 1,
- "(MenuCommand commandID) -> None"},
+ "(MenuCommand inCommandID) -> None"},
#endif
#if TARGET_API_MAC_CARBON
{"IsMenuCommandEnabled", (PyCFunction)MenuObj_IsMenuCommandEnabled, 1,
- "(MenuCommand commandID) -> (Boolean _rv)"},
+ "(MenuCommand inCommandID) -> (Boolean _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"SetMenuCommandMark", (PyCFunction)MenuObj_SetMenuCommandMark, 1,
+ "(MenuCommand inCommandID, UniChar inMark) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"GetMenuCommandMark", (PyCFunction)MenuObj_GetMenuCommandMark, 1,
+ "(MenuCommand inCommandID) -> (UniChar outMark)"},
#endif
#if TARGET_API_MAC_CARBON
{"GetMenuCommandPropertySize", (PyCFunction)MenuObj_GetMenuCommandPropertySize, 1,
- "(MenuCommand commandID, OSType propertyCreator, OSType propertyTag) -> (ByteCount size)"},
+ "(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> (ByteCount outSize)"},
#endif
#if TARGET_API_MAC_CARBON
{"RemoveMenuCommandProperty", (PyCFunction)MenuObj_RemoveMenuCommandProperty, 1,
- "(MenuCommand commandID, OSType propertyCreator, OSType propertyTag) -> None"},
+ "(MenuCommand inCommandID, OSType inPropertyCreator, OSType inPropertyTag) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"IsMenuItemInvalid", (PyCFunction)MenuObj_IsMenuItemInvalid, 1,
+ "(MenuItemIndex item) -> (Boolean _rv)"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"InvalidateMenuItems", (PyCFunction)MenuObj_InvalidateMenuItems, 1,
+ "(MenuItemIndex firstItem, ItemCount numItems) -> None"},
+#endif
+
+#if TARGET_API_MAC_CARBON
+ {"UpdateInvalidMenuItems", (PyCFunction)MenuObj_UpdateInvalidMenuItems, 1,
+ "() -> None"},
#endif
#if TARGET_API_MAC_CARBON
{
PyObject *_res = NULL;
OSStatus _err;
- MenuID menuID;
- MenuAttributes menuAttributes;
+ MenuID inMenuID;
+ MenuAttributes inMenuAttributes;
MenuHandle outMenuRef;
#ifndef CreateNewMenu
PyMac_PRECHECK(CreateNewMenu);
#endif
if (!PyArg_ParseTuple(_args, "hl",
- &menuID,
- &menuAttributes))
+ &inMenuID,
+ &inMenuAttributes))
return NULL;
- _err = CreateNewMenu(menuID,
- menuAttributes,
+ _err = CreateNewMenu(inMenuID,
+ inMenuAttributes,
&outMenuRef);
if (_err != noErr) return PyMac_Error(_err);
_res = Py_BuildValue("O&",
{
PyObject *_res = NULL;
OSStatus _err;
- MenuBarHandle mbar;
- MenuBarHandle outBar;
+ MenuBarHandle inMbar;
+ MenuBarHandle outMbar;
#ifndef DuplicateMenuBar
PyMac_PRECHECK(DuplicateMenuBar);
#endif
if (!PyArg_ParseTuple(_args, "O&",
- ResObj_Convert, &mbar))
+ ResObj_Convert, &inMbar))
return NULL;
- _err = DuplicateMenuBar(mbar,
- &outBar);
+ _err = DuplicateMenuBar(inMbar,
+ &outMbar);
if (_err != noErr) return PyMac_Error(_err);
_res = Py_BuildValue("O&",
- ResObj_New, outBar);
+ ResObj_New, outMbar);
return _res;
}
#endif
{
PyObject *_res = NULL;
OSStatus _err;
- MenuBarHandle mbar;
+ MenuBarHandle inMbar;
#ifndef DisposeMenuBar
PyMac_PRECHECK(DisposeMenuBar);
#endif
if (!PyArg_ParseTuple(_args, "O&",
- ResObj_Convert, &mbar))
+ ResObj_Convert, &inMbar))
return NULL;
- _err = DisposeMenuBar(mbar);
+ _err = DisposeMenuBar(inMbar);
if (_err != noErr) return PyMac_Error(_err);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-static PyObject *Menu_SetMenuFlashCount(PyObject *_self, PyObject *_args)
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *Menu_SetMenuFlash(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
short count;
-#ifndef SetMenuFlashCount
- PyMac_PRECHECK(SetMenuFlashCount);
+#ifndef SetMenuFlash
+ PyMac_PRECHECK(SetMenuFlash);
#endif
if (!PyArg_ParseTuple(_args, "h",
&count))
return NULL;
- SetMenuFlashCount(count);
+ SetMenuFlash(count);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
+#endif
-#if !TARGET_API_MAC_CARBON
-
-static PyObject *Menu_SetMenuFlash(PyObject *_self, PyObject *_args)
+static PyObject *Menu_SetMenuFlashCount(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
short count;
-#ifndef SetMenuFlash
- PyMac_PRECHECK(SetMenuFlash);
+#ifndef SetMenuFlashCount
+ PyMac_PRECHECK(SetMenuFlashCount);
#endif
if (!PyArg_ParseTuple(_args, "h",
&count))
return NULL;
- SetMenuFlash(count);
+ SetMenuFlashCount(count);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
}
-#endif
static PyObject *Menu_FlashMenuBar(PyObject *_self, PyObject *_args)
{
return _res;
}
+#if TARGET_API_MAC_CARBON
+
+static PyObject *Menu_AcquireRootMenu(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ MenuHandle _rv;
+#ifndef AcquireRootMenu
+ PyMac_PRECHECK(AcquireRootMenu);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = AcquireRootMenu();
+ _res = Py_BuildValue("O&",
+ MenuObj_New, _rv);
+ return _res;
+}
+#endif
+
static PyObject *Menu_DeleteMCEntries(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
return _res;
}
+static PyObject *Menu_LMGetTheMenu(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ SInt16 _rv;
+#ifndef LMGetTheMenu
+ PyMac_PRECHECK(LMGetTheMenu);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetTheMenu();
+ _res = Py_BuildValue("h",
+ _rv);
+ return _res;
+}
+
#if !TARGET_API_MAC_CARBON
static PyObject *Menu_OpenDeskAcc(PyObject *_self, PyObject *_args)
#if TARGET_API_MAC_CARBON
{"CreateNewMenu", (PyCFunction)Menu_CreateNewMenu, 1,
- "(MenuID menuID, MenuAttributes menuAttributes) -> (MenuHandle outMenuRef)"},
+ "(MenuID inMenuID, MenuAttributes inMenuAttributes) -> (MenuHandle outMenuRef)"},
#endif
{"MenuKey", (PyCFunction)Menu_MenuKey, 1,
"(CharParameter ch) -> (long _rv)"},
#if TARGET_API_MAC_CARBON
{"DuplicateMenuBar", (PyCFunction)Menu_DuplicateMenuBar, 1,
- "(MenuBarHandle mbar) -> (MenuBarHandle outBar)"},
+ "(MenuBarHandle inMbar) -> (MenuBarHandle outMbar)"},
#endif
#if TARGET_API_MAC_CARBON
{"DisposeMenuBar", (PyCFunction)Menu_DisposeMenuBar, 1,
- "(MenuBarHandle mbar) -> None"},
+ "(MenuBarHandle inMbar) -> None"},
#endif
{"GetMenuHandle", (PyCFunction)Menu_GetMenuHandle, 1,
"(MenuID menuID) -> (MenuHandle _rv)"},
"(MenuID menuID) -> None"},
{"ClearMenuBar", (PyCFunction)Menu_ClearMenuBar, 1,
"() -> None"},
- {"SetMenuFlashCount", (PyCFunction)Menu_SetMenuFlashCount, 1,
- "(short count) -> None"},
#if !TARGET_API_MAC_CARBON
{"SetMenuFlash", (PyCFunction)Menu_SetMenuFlash, 1,
"(short count) -> None"},
#endif
+ {"SetMenuFlashCount", (PyCFunction)Menu_SetMenuFlashCount, 1,
+ "(short count) -> None"},
{"FlashMenuBar", (PyCFunction)Menu_FlashMenuBar, 1,
"(MenuID menuID) -> None"},
"() -> None"},
{"HideMenuBar", (PyCFunction)Menu_HideMenuBar, 1,
"() -> None"},
+
+#if TARGET_API_MAC_CARBON
+ {"AcquireRootMenu", (PyCFunction)Menu_AcquireRootMenu, 1,
+ "() -> (MenuHandle _rv)"},
+#endif
{"DeleteMCEntries", (PyCFunction)Menu_DeleteMCEntries, 1,
"(MenuID menuID, short menuItem) -> None"},
{"InitContextualMenus", (PyCFunction)Menu_InitContextualMenus, 1,
"() -> None"},
{"IsShowContextualMenuClick", (PyCFunction)Menu_IsShowContextualMenuClick, 1,
"(EventRecord inEvent) -> (Boolean _rv)"},
+ {"LMGetTheMenu", (PyCFunction)Menu_LMGetTheMenu, 1,
+ "() -> (SInt16 _rv)"},
#if !TARGET_API_MAC_CARBON
{"OpenDeskAcc", (PyCFunction)Menu_OpenDeskAcc, 1,
"GetMenuCommandProperty",
"GetMenuTitle", # Funny arg/returnvalue
"SetMenuTitle",
+ "SetMenuTitleIcon", # void*
]
def makegreylist(self):
'GetMenuAttributes',
'ChangeMenuItemPropertyAttributes',
'GetMenuItemPropertyAttributes',
-
+ 'AcquireRootMenu',
+ 'UpdateInvalidMenuItems',
+ 'InvalidateMenuItems',
+ 'IsMenuItemInvalid',
+ 'GetMenuCommandMark',
+ 'SetMenuCommandMark',
+ 'GetMenuType',
+ 'SetMenuItemCommandKey',
+ 'GetMenuItemCommandKey',
+ 'SetMenuItemIndent',
+ 'GetMenuItemIndent',
+ 'SetMenuItemTextWithCFString',
+ 'CopyMenuItemTextAsCFString',
+ 'GetMenuItemHierarchicalMenu',
+ 'SetMenuItemHierarchicalMenu',
+ 'SetRootMenu',
+ 'IsMenuBarInvalid',
+ 'InvalidateMenuEnabling',
+ 'InsertMenuItemTextWithCFString',
+ 'AppendMenuItemTextWithCFString',
+ 'DeleteMenuItems',
+ 'CopyMenuItems',
+ 'IsMenuSizeInvalid',
+ 'InvalidateMenuSize',
+ 'SetMenuTitleWithCFString',
+ 'CopyMenuTitleAsCFString',
+ 'DuplicateMenu',
+ 'ReleaseMenu',
+ 'RetainMenu',
+ 'GetMenuRetainCount',
+ 'IsValidMenu',
])]
def makeblacklisttypes(self):
"MenuDefSpecPtr", # Too difficult for now
"MenuDefSpec_ptr", # ditto
"MenuTrackingData",
+ "void_ptr", # Don't know yet.
+ "EventRef", # For now, not exported yet.
+ "MenuItemDataPtr", # Not yet.
+ "MenuItemDataRec_ptr",
]
def makerepairinstructions(self):
MenuBarHandle = OpaqueByValueType("MenuBarHandle", "ResObj")
MenuID = Type("MenuID", "h")
MenuItemIndex = Type("MenuItemIndex", "h")
+MenuItemID = Type("MenuItemID", "l")
MenuCommand = Type("MenuCommand", "l")
MenuAttributes = Type("MenuAttributes", "l")
MenuItemAttributes = Type("MenuItemAttributes", "l")
unsigned_char = Type('unsigned char', 'b')
FMFontFamily = Type("FMFontFamily", "h")
FMFontStyle = Type("FMFontStyle", "h")
+CFStringRef = OpaqueByValueType("CFStringRef", "CFStringRefObj")
+UniChar = Type("UniChar", "h")
includestuff = includestuff + """
#ifdef WITHOUT_FRAMEWORKS
}
#endif
+static PyObject *TE_LMGetWordRedraw(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt8 _rv;
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ _rv = LMGetWordRedraw();
+ _res = Py_BuildValue("b",
+ _rv);
+ return _res;
+}
+
+static PyObject *TE_LMSetWordRedraw(PyObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+ UInt8 value;
+ if (!PyArg_ParseTuple(_args, "b",
+ &value))
+ return NULL;
+ LMSetWordRedraw(value);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+
static PyObject *TE_as_TE(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
{"TESetScrapHandle", (PyCFunction)TE_TESetScrapHandle, 1,
"(Handle value) -> None"},
#endif
+ {"LMGetWordRedraw", (PyCFunction)TE_LMGetWordRedraw, 1,
+ "() -> (UInt8 _rv)"},
+ {"LMSetWordRedraw", (PyCFunction)TE_LMSetWordRedraw, 1,
+ "(UInt8 value) -> None"},
{"as_TE", (PyCFunction)TE_as_TE, 1,
"(Handle h) -> (TEHandle _rv)"},
{NULL, NULL, 0}
projects / python / commitdiff